《数据结构邓版》学习笔记-第二章vector

最新推荐文章于 2025-01-12 21:32:44 发布
原创 最新推荐文章于 2025-01-12 21:32:44 发布 · 216 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #学习 #c++

本文介绍了一个通用向量容器的实现细节，包括构造、赋值、动态调整大小等核心功能，以及排序、查找、删除等实用算法。这些算法适用于C++等支持泛型编程的语言。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

代码2.2 基于赋值的向量构造器

copyFrom()首先根据待复制区间的边界，换算初新向量的初始规模；再以双倍的容量，为内部数组_elem[]申请空间。最后通过一趟迭代，完成区间A[lo, hi]内各元素的顺次复制。

template<typename T>

void Vector<T>::copyForm(T const* A, Rank o, Rank hi)

{

    _elem = new T[_capacity = 2 * (hi - locale)];

    _size = 0;

    while (lo < hi)

        _elem[_size++] = A[lo++];

}

代码2.3重载向量赋值操作符

operator=()首先释放原有内容，然后再整体复制，最后返回当前对象的引用。

template<typename T>

Vector<T>& Vector<T>::operator=(Vector<T> const& V)

{

    if (_elem)

        delete[]_elem;

    copyForm(V._elem, 0, V.size());

    return *this;

}

代码2.4 向量内部数组动态扩容算法expand()

Expand()首先判断是否满员，再判断是否低于默认容量，然后是容量加倍，然后是复制原向量内容，最后是释放原空间。

template<typename T>

void Vector<T>::expand()

{

    if (_size < _capacity)

        return;

    if (_capacity < DEFAULT_CAPACITY)

        _capacity = DEFAULT_CAPACITY;

    T* oldElem = _elem;

    _elem = new T[_capacity <<= 1];

    for (int i = 0; i < _size; i++)

        _elem[i] = oldElem[i];

    delete[] oldElem;

}

代码2.5 向量内部功能shrink()

Shrink()实现步骤与expand()类似，当空间利用率已降至某一阀值以下，就立即申请一个容量减半的新数组，将原数组的元素逐一搬迁至其中，最后将原数组所占空间交还操作系统。

template<typename T>

void Vector<T>::shrink()

{

    if (_capacity < DEFAULT_CAPACITY << 1)return;

    if (_size << 2 > _capacity)return;

    T* oldElem = _elem;

    _elem = new T[_capacity >>= 1];

    for (int i = 0; i < _size; ++i)

        _elem[i] = oldElem[i];

    delete[] oldElem;

}

代码2.6 重载向量操作符[]

template <typename T>

T& Vector<T>::operator[](Rank r)const

{

    return _elem[r];

}

代码2.7 向量整体置乱算法permute()

permute()算法从待置乱区间的末元素开始，逆序地向前逐一处理各元素。

template <typename T>

void permute(Vector<T>& V)

{

    for (int i = V.size(); i > 0; i--)

        swap(V[i - 1], V[rand() % i]);

}

代码2.8 向量区间置乱接口unsort()

unsort()均匀的置乱lo，hi区间内的元素，整体套用permute函数。

template<typename T>

void Vector<T>::unsort(Rank lo, Rank hi)

{

    T* V = _elem + lo;

    for (Rank i = hi - lo; i > 0; i--)

        swap(V[i - 1], V[rand() % i]);

}

代码2.10 无序向量元素查找接口find()

find()自后向前，顺序查找，返回hi，要么失败，要么返回hi命中的元素。

template<typename T>

Rank Vector<T>::find(T const& e, Rank lo, Rank hi)const

{

    while ((lo < hi--) && (e != _elem[hi]));

    return hi;

}

代码2.11 向量元素插入接口insert()

Insert()负责将任意给定的元素e插入到任意指定的秩为r的单元。首先判断是否将要移出，若有必要，扩容。然后自后向前，顺序后移一个单元，再将新元素放入r的位置的变量，并更新容量，最后返回秩。

template<typename T>

Rank Vector<T>::insert(Rank r, T const& e)

{

    expand();

    for (int i = _size; i > r; i--)

        _elem[i] = _elem[i - 1];

    _elem[r] = e;

    _size++;

    return r;

}

代码2.12 向量区间删除接口remove()

remove()首先单独处理退化情况。再将[hi, _size]顺次前移hi – lo个单元，然后更新规模，直接丢弃尾部[lo, _size = hi)区间。有必要就缩容。最后返回被删减元素的数目。

template<typename T>

int Vector<T>::remove(Rank lo, Rank hi)

{

    if (lo == hi)

        return 0;

    while (hi < _size)

        _elem[lo++] = _elem[hi++];

    _size = lo;

    shrink();

    return hi - lo;

}

代码2.13 向量单元素删除接口remove()

remove()首先备份被删除的元素，然后调用区间删除算法，等效于对区间[r, r+ 1]的删除，返回被删除元素。

template<typename T>

T Vector<T>::remove(Rank r)

{

    T e = _elem[r];

    remove(r, r + 1);

    return e;

}

代码2.14 无序向量清除重复元素接口deduplicate()

Deduplicate()函数自前向后逐一考查各元素_elem[i],并通过调用find()接口，查找雷同者，找到就调用remove()删除，最后就返回被删除元素总数。

template<typename T>

int Vector<T>::deduplicate()

{

    int oldSize = _size;

    Rank i = 1;

    while (i < _size)

        (find(_elem[i], 0, i) < 0) ? i++ : remove(i);

    return oldSize - _size;

}

代码2.15 向量遍历接口traverse()

traverse()借助函数指针或函数对象自前向后组逐一对各元素实施同一基本操作。

template<typename T>

void Vector<T>::traverse(void (*visit)(T&))

{

    for (int i = 0; i < _size; i++)

        visit(_elem[i]);

}

template<typename T>

template<typename VST>

void Vector<T>::traverse(VST& visit)

{

    for (int i = 0; i < _size; i++)

        visit(_elem[i]);

}

代码2.16 基于遍历实现increase()功能

设立一个函数对象，里面只有一个operator()函数，然后设立一个increase()函数调用traverse()函数。

template<typename T>

struct Increase

{

    virtual void operator()(T& e)

    {

        e++;

    }

};

template<typename T>

void increase(Vector<T>& V)

{

    V.traverse(Increase<T>());

}

代码2.17 有序向量甄别算法disordered()

disordered()函数首先设立一个计数器，然后逐一检查_size – 1 对相邻元素，如果逆序则计数，最后返回计数值。

template<typename T>

int Vector<T>::disordered()const

{

    int n = 0;

    for (int i = 1; i < _size; i++)

        if (_elem[i - 1] > _elem[i])

             n++;

    return n;

}

代码2.18 有序向量uniquify()接口的平凡实现

自前向后，逐一对比各对相邻元素，若相同就删除后者，否则转至下一元素，最后返回变化的规模。

template<typename T>

int Vector<T>::uniquify()

{

    int oldSize = _size;

    int i = 1;

    while (i < _size)

        _elem[i - 1] == _elem[i] ? remove(i) : i++;

    return oldSize - _size;

}

代码2.19 有序向量uniquify()接口的高效实现

首先初始化两个表示位，组逐一扫描，直到末元素，其中若发现相同者，就跳过，否则就向前移至前者右侧。最后更新_size, shrink()，返回被删除元素总数。

template<typename T>

int Vector<T>::uniquify()

{

    Rank i = 0, j = 0;

    while (++j < _size)

        if (_elem[i] != _elem[j])

             _elem[++i] = _elem[j];

    _size = ++i;

    shrink();

    return j - i;

}

代码2.20 有序向量各种查找算法的统一search()接口

主要是随机判断调用binSearch()还是fibSearch()函数。

template<typename T>

Rank Vector<T>::search(T const& e, Rank lo, Rank hi)const

{

    return (rand() % 2) ? binSearch(_elem, e, lo, hi) : fibSearch(_elem, e, lo, hi);

}

代码2.21 二分查找版本A

在有序向量区间[lo, hi)内查找e，该算法以中点mi为界，判断比较，最后失败返回-1，成功返回mi。

template<typename T>

static Rank binSearch(T* A, T const& e, Rank lo, Rank hi)

{

    while (lo < hi)

    {

        Rank mi = (lo + hi) >> 1;

        if (e < A[mi])

             hi = mi;

        else if (A[mi] < e)

             lo = mi + 1;

        else

             return mi;

    }

    return -1;

}

代码2.22 Fibonacci查找算法

需要有之前的fibonacci类。具体要自己分析。

template<typename T>

static Rank fibsearch(T* A, T const& e, Rank lo, Rank hi)

{

    Fib fib(hi - lo);

    while (lo < hi)

    {

        while (hi - lo < fib.get())

             fib.prev();

        Rank mi = lo + fib.get() - 1;

        if (e < A[mi])

             hi = mi;

        else if (A[mi] < e)

             lo = mi + 1;

        else

             return mi;

    }

    return -1;

}

代码2.23 二分查找版本B

于版本A在于划分不同，[lo, mi)和[mi, hi]。

template<typename T>

static Rank binSearch(T* A, T const& e, Rank lo, Rank hi)

{

    while (1 < hi - lo)

    {

        Rank mi = (lo + hi) >> 1;

        (e < A[mi]) ? hi = mi : lo = mi;

    }

    return (e == A[lo]) ? lo : -1;

}

代码2.24 二分查找版本C

和版本B在于失败时返回的值是不大于e的最大秩。

template<typename T>

static Rank binSearch(T* A, T const& e, Rank lo, Rank hi)

{

    while (lo < hi)

    {

        Rank mi = (lo + hi) >> 1;

        (e < A[mi]) ? hi = mi : lo = mi + 1;

    }

    return --lo;

}

代码2.25 向量排序器接口

随机选取一种排序函数。

template<typename T>

void Vector<T>::sort(Rank lo, Rank hi)

{

    switch (rand() % 5)

    {

    case 1: bubbleSort(lo, hi);

        break;

    case 2: selectionSort(lo, hi);

        break;

    case 3:mergeSort(lo, hi);

        break;

    case 4:heapSort(lo, hi);

        break;

    default: quickSort(lo, hi);

        break;

    }

}

代码2.26 向量的气泡排序

将bubble集成到bubbleSort里面。

template<typename T>

void Vector<T>::bubbleSort(Rank lo, Rank hi){

    while (!bubble(lo, hi--));

}

代码2.27 单躺扫描交换

主要相对于之前的bubbleSort加入了flag位，主要其减少时间复杂度。与代码2.26结合使用。

template<typename T>

bool Vector<T>::bubble(Rank lo, Rank hi)

{

    bool sorted = true;

    while (++lo < hi)

    {

        if (_elem[lo - 1] > _elem[lo])

             sorted = false;

        swap(_elem[lo - 1], _elem[lo]);

    }

    return sorted;

}

代码2.28 向量的归并排序

主要是采用归并算法是递归算法，有递归基，以中点为界不断划分，然后分别排序，最后合并。

template<typename T>

void Vector<T>::mergeSort(Rank lo, Rank hi)

{

    if (hi - lo < 2)

        return;

    int mi = (lo + hi) >> 1;

    mergeSort(lo, mi);

    mergeSort(mi, hi);

    merge(lo, mi, hi);

}

代码2.29 有序向量的二路归并

首先定义合并后的向量A[0, hi – lo),定义前子向量B[0, lb)，在复制前子向量，同理定义后子向量C。然后判定B和C中的小者复制到A里面，最后删除临时空间。

template<typename T>

Rank Vector<T>::merge(Rank lo, Rank mi, Rank hi)

{

    T* A = _elem + lo;

    int lb = mi - lo;

    T* B = new T[lb];

    for (Rank i = 0; i < lb; B[i] = A[i++]);

    int lc = hi - mi;

    T* C = _elem + mi;

    for (Rank i = 0, j = 0, k = 0; (j < lb) || (k < lc);)

    {

        if ((j < lb) && (!(k < lc) || (B[j] <= C[k])))

             A[i++] = B[j++];

        if ((k < lc) && (!(j < lb) || (C[k] < B[j])))

             A[i++] = C[k++];

    }

    delete[]B;

}

【专栏必读】王道考研408数据结构+算法设计与分析万字笔记使用说明及章节导航
快乐江湖的博客
11-23 5万+
各位老铁思维导图在我整理完笔记后会放上去的，我需要根据王道的思维导图重新再做一遍 文章目录一：有关注意事项二：关于专栏三：学习建议四：各专栏导航（各位老铁别催，质量优先）（1）第一章：绪论（2）第二章：线性表（3）第三章：栈和队列第四章：串第五章：二叉树第六章：图 首先感谢王道大大（手动比心），很用心在做了，大家可以看其中两节是否符合胃口 (王道408考研数据结构)第五章树-第三节1：二叉树遍历（先序、中序和后序） (王道408考研数据结构)第五章树-第四节2：平衡二叉树(AVL)及其旋转 一：有.
【AI大模型应用学习笔记】RAG-Embedding-Vector知识点学习
最新发布
etrospect的博客
05-10 663
关于RAG-Embedding-Vector知识点，以及RAG实现的基本流程实操记录
数据结构和算法（5）：二叉树
学习记录
09-12 651
数据结构学习笔记
二叉树（BinTree）
嘟嘟的博客
01-28 1199
BinTree 树是半线性结构，分层结构，具有无环性 二叉树的身影几乎出现在所有应用领域中 沿每个节点到根的唯一通路所经过的边的数目，称作节点的深度。 每个节点的孩子总数，称作其节点的度数或度。 树中所有节点的深度的最大值称作该树的高度。 仅含单个节点的树高度为 0，空树高度为 -1。 不含一度节点的二叉树称作真二叉树。 通讯 在开始通讯之前，双方应已经以某种方式，就编码规则达成过共同的约定或协议。 二进制编码： PFC 编码 → 前缀无歧义编码：任何两个原始字符所对应的二进制编码串，相互都不
数据结构与算法学习1.1：数据结构之向量(C++语言实现)
panzl1234的博客
05-02 810
学习书籍：数据结构(C++语言版) 邓俊辉 环境：Win10 VS2017 注意事项： 1.模板类成员函数的声明和定义都放在头文件中。 2.头文件中尽可能不使用using namespace std;引入名称空间类似操作。 代码会与邓俊辉老师的有略微不同之处，自己去写总会踩到一些C++语言的坑，同时当做C++的学习，代码都是检查过可运行的，可以直接使用，若存在BUG请及时指正错误。 在定义数组的时...
C++中的 template ＜typename T＞
qq_63624313的博客
09-12 1010
C++中的 template
c++数据结构：数组和向量
qq_45303986的博客
10-10 2144
A[i,j] 每个元素的长度为3，i的范围为1-8 j的范围为1-10，首地址为G。c[0]代表的是以c[0][0]为首地址的一维数组（将数组c摊开）一般用二维数组来存储矩阵元。在数据元素的非空有限集中。计算A[5,8]的地址。
学习《动手学大模型开发》笔记--第二章
aiyan429的博客
03-19 1147
要实现自定义 LLM，需要定义一个自定义类继承自 LangChain 的 LLM 基类，然后定义两个函数：① _call 方法，其接受一个字符串，并返回一个字符串，即模型的核心调用；②_identifying_params 方法，用于打印 LLM 信息。#导入所需的第三方库##定义一个 get_access_token 方法来获取 access_token：## 指定网址client_id=#填写API_Key#"
从零开始逐步指导开发者构建自己的大型语言模型（LLM）学习笔记- 第2章 Working with Text
chenchihwen的专栏
01-04 1080
return ids!定义了一个简单的标记器类，包含初始化方法__init__、编码方法encode和解码方法decode。encode方法将文本转换为标记 ID，decode方法将标记 ID 转换回文本。这段代码定义了一个类。**一、`__init__`方法**1. 它接受一个词汇表`vocab`作为参数。
从零开始逐步指导开发者构建自己的大型语言模型（LLM）学习笔记- 第4章 GPT 的大语言模型架构Implementing a GPT model
chenchihwen的专栏
01-12 1101
回顾从零搭建 GPT 模型的关键步骤，包括架构设计、组件实现、训练与生成。强调层归一化、GELU 激活、快捷连接等技术对模型性能的提升作用。
数据结构(C++)——二叉树的遍历：先序,后序,中序,层次遍历
amoscykl的博客
08-02 3623
递归式遍历   1.先序遍历 template &lt;typename T, typename VST&gt; //元素类型、操作器 void travPre_R(BinNodePosi(T) x, VST&amp; visit) { //二叉树先序遍历算法 if (!x) return; visit( x-&gt;data); travPre...
C++ 中 参数包 (typename ...) 学习笔记
LucienShui
12-23 1万+
C++ 中 参数包 (typename …) 学习笔记 本文所属地址 https://www.lucien.ink 起因 突然好奇 STL 的 std::tuple 是怎么实现不定参数的，遂搜了搜，发现了 template &amp;lt;typename ...&amp;gt; 这个东西，继续搜了一下，发现中文资料很少，在 GoogleGoogleGoogle 上用英文搜了一下才找到比较好的资料。 其实 cpp...
二叉树的遍历
u011575841的专栏
01-03 486
二叉树的遍历分为递归和非递归。渐进的时间复杂度都是O(n)，非递归算法由于没有函数递归调用的开销，有比较好的空间复杂度。 代码是根据邓俊辉老师的书来写的。 代码： //traverse a binary tree in recursive or non recursive way #include #include #include #include #include using
C++及数据结构复习笔记（十三）（二叉树）
Lao_tan的博客
07-15 1500
2.4 二叉树       树属于半线性结构。2.4.1 二叉树及其表示       从图论的角度看，树等价于联通无环图。沿每个节点v到根r的唯一通路所经过的边的数目，称为v的深度depth，记作depth(v)。根节点的深度为0，属于第0层。在每一层上，v的祖先至多有一个。v的孩子的总数称为v的度，无孩子的节点称为叶节点，包括根在内的其余节点均为内部节点。树T中所有节点深度的最大值称为该树的高度...
清华邓俊辉数据结构学习笔记（3） - 二叉树、图
weixin_42194879的博客
01-15 775
第五章 二叉树 （a）树 树能够结合向量的优点（search）和列表的优点（insert、remove），构成List< List >。 有根树 树是特殊的图 T = (V, E)，节点数 |V| = n，边数 |E| = e，指定任一节点 r ∈ V作为根后，T即称作有根树。 若T1，T2，…，Td为有根树，则 T = ( (∪Vi) ∪ {r}, (∪Ei) ∪ { <r, ...
简述类模板函数模板template （typename T）
卖炫迈的小男孩的博客
09-08 1万+
相信很多刚入门c++的同学在学数据结构或者查看大佬的代码中，我们都会看到: template <typename T> 类模板; template<typename T> class A { public: …… protected： …… }; 或者： 函数模板： 本文只是简单说明一下我们使用类模板和函数模板需要注意什么（因为我...
5.5 二叉树的遍历
ZXG20000的博客
04-15 171
1. 递归遍历 //先序遍历 template <typename T, typename VST> void travPre(BinNodePosi(T) x, VST& visit) { if( !x ) return; //BinNodePosi(T) x = root(); visit( x->data ); travPre( x->lc, visit ); travPre( x->rc, visit ); } //后序遍历 template &l
template＜typename T＞简单用法
热门推荐
realjc的博客
09-09 2万+
template<typename T>的作用是使函数适用于不同的输入类型。 template<typename T> void print_num(const T num){ cout.setf(ios::showpoint); cout<<num<<endl; } int main () { int num1 = 1; print_num(num1); double num2 = 1.0; print
数据结构习题解析5-18（邓俊辉老师第3版）
weixin_42475223的博客
03-08 844
template <typename T> template <typename VST> //元素类型、操作器 void BinNode<T>::travLevel(VST& visit) //二叉树层次遍历算法 { Queue<BinNodePosi(T)> Q; //辅助队列 Q.enqueue(this); while (!...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值