【C++】数据结构——向量

最新推荐文章于 2024-06-06 13:09:29 发布
最新推荐文章于 2024-06-06 13:09:29 发布
阅读量3.6k 收藏 26
点赞数 3
分类专栏： C++学习 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JesseGrowing/article/details/123162453
版权
本文档详细介绍了如何实现一个基于向量的抽象数据类型（ADT），包括其构造函数、只读和可写接口、运算符重载、动态空间管理、排序、查找、删除和去重等操作。向量类使用模板实现，支持不同类型的元素，并通过数组进行存储。此外，还讨论了冒泡排序、二分查找等算法在向量操作中的应用。
摘要由CSDN通过智能技术生成

向量

参考书籍：《数据结构（C++语言版）》邓俊辉著

向量（vector）是最基本的线性数据结构——序列（sequence）中的一种。向量中。所有数据项的物理存放位置与其逻辑次序一致，其逻辑次序被称作秩（rank）。

C++中已经有实现向量的库<vector>，我们不使用该库，而是仿照它实现一种基于向量的抽象数据类型（Abstract Data Type，ADT）。

ADT接口

下面列出需要实现的接口：

操作接口功能适用对象
size ( )返回向量规模向量
get ( r )获取秩为r的元素向量
put ( r, e )用e替换秩为r的元素向量
insert ( r, e )在秩为r的位置插入元素e向量
remove ( r )删除秩为r的对象并返回向量
disordered ( )判断是否逆序，返回逆序数向量
sort ( )非降序重新排列向量
find ( e )查找目标元素，返回最大的秩向量
search ( e )查找目标元素，返回最大的秩有序向量
deduplicate ( )删除重复元素向量
uniquify ( )删除重复元素有序向量
traverse ( )遍历向量并统一处理向量

Vector模板类

下面定义Vector模板类：

typedef int Rank;
#define DEFAULT_CAPACITY 3

template <typename T>
class Vector
{
protected:
    Rank _size;                                  //元素个数
    int _capacity;                               //实际空间
    T *_elem;                                    //元素指针
    void copyFrom(T const *A, Rank lo, Rank hi); //从A中复制区间[lo, hi)
    void expand();                               //空间不足时扩容
    void shrink();                               //装填因子过小时压缩空间
    bool bubble(Rank lo, Rank hi);				 //冒泡排序的基本操作，扫描交换
public:
    //构造函数
    Vector(int c = DEFAULT_CAPACITY, int s = 0, T v = 0)
    {
        _elem = new T[_capacity = c];
        for (_size = 0; _size < s; _elem[_size++] = v)
            ;
    }
    Vector(T const *A, Rank n) { copyFrom(A, 0, n); }                           //从数组复制
    Vector(T const *A, Rank lo, Rank hi) { copyFrom(A, lo, hi); }               //复制数组区间
    Vector(Vector<T> const &V) { copyFrom(V._elem, 0, V._size); }               //拷贝构造
    Vector(Vector<T> const &V, Rank lo, Rank hi) { copyFrom(V._elem, lo, hi); } //复制向量区间
    //析构函数
    ~Vector() { delete[] _elem; } //删除数组
    //只读接口
    Rank size() const { return _size; }                                               //返回最大秩
    bool empty() const { return !_size; }                                             //判空
    int disordered() const;                                                           //返回逆序数
    Rank find(T const &e) const { return find(e, 0, _size); }                         //无序向量整体查找
    Rank find(T const &e, Rank lo, Rank hi) const;                                    //无序向量区间查找
    Rank search(T const &e) const { return (_size <= 0) ? -1 : search(e, 0, _size); } //有序向量整体查找
    Rank search(T const &e, Rank lo, Rank hi) const;                                  //有序向量区间查找
    //可写入接口
    T &operator[](Rank r) const;                         //重载[]操作符，使其能够像数组一样引用元素
    Vector<T> &operator=(Vector<T> const &);             //重载=操作符，使其能够向数组一样赋值
    T remove(Rank r);                                    //删除秩为r的元素
    Rank insert(Rank r, T const &e);                     //在秩为r的位置插入元素e
    Rank insert(T const &e) { return insert(_size, e); } //在末尾插入元素e
    void sort(Rank lo, Rank hi);                         //对[lo, hi)区间排序
    void sort() { sort(0, _size); }                      //整体排序
    void unsort(Rank lo, Rank hi);                       //对[lo, hi)区间置乱
    void unsort() { unsort(0, _size); }                  //整体置乱
    int deduplicate();                                   //无序去重
    int uniquify();                                      //有序去重
    //遍历操作
    void traverse(void (*)(T &)); //使用函数指针操作
    template <typename VST>
    void traverse(VST &); //使用函数对象操作
};

对于只读的接口，尽量将其声明为const类型。

初始化函数

由于向量的特性，我们选择数组这一结构作为向量类的基本元素单元，因为数组在内存中的物理地址与其逻辑次序一致。

构造函数在类声明中已经内联的实现了，下面实现内部的复制函数：

template <typename T>
void Vector<T>::copyFrom(T const *A, Rank lo, Rank hi)
{
    _elem = new T[_capacity = 2 * (hi - lo)]; //申请空间
    _size = 0;                                //规模置零
    while (lo < hi)
    {
        _elem[_size++] = A[lo++]; //逐个复制
    }
}

根据模板参数T的不同，向量模板会自动请求合适的内存。

运算符重载

我们目前只需要重载=赋值操作符和[]取元素操作符：

template <typename T>
Vector<T> &Vector<T>::operator=(const Vector<T> &V)
{
    delete[] _elem;	//删除原有空间，因为下面会申请新的空间
    copyFrom(V._elem, 0, V._size);
    return *this; //返回值为引用便于链式赋值
}

返回值为引用，这样就可以实现链式赋值（即连等）。

template <typename T>
T &Vector<T>::operator[](Rank r) const
{
    return _elem[r];
}

动态空间管理

在可用空间足够小时扩容，在剩余空间足够大时缩容，一般发生在向量修改前后：

template <typename T>
void Vector<T>::expand()
{
    while (_size == _capacity) //若实际规模等于容量
    {
        T *oldElem = _elem;
        _elem = new T[_capacity <<= 1]; //申请两倍的新的空间
        for (int i = 0; i < _size; i++)
        {
            _elem[i] = oldElem[i]; //若T为非基本类型，则该类型需重载=操作符
        }
        delete[] oldElem; //释放原空间
    }
}

扩容两倍的空间，这是有理论依据的。当发生足够多次的插入操作时，每次将容量扩大一倍的平摊时间成本最低，为O(1)。

template <typename T>
void Vector<T>::shrink()
{
    while (_size << 2 < _capacity) //若实际规模不到容量的1/4，则缩容
    {
        T *oldElem = _elem;
        _elem = new T[_capacity >>= 1]; //申请原来一半的空间
        for (int i = 0; i < _size; i++)
        {
            _elem[i] = oldElem[i]; //若T为非基本类型，则该类型需重载=操作符
        }
        delete[] oldElem; //释放原空间
    }
}

装填因子 = _size / _capacity ，我们选择25%作为装填因子的下限。

逆序与置乱

在必要时，可以将向量重新随机排序（需要先引入<random>库）：

template <typename T>
void Vector<T>::unsort(Rank lo, Rank hi)
{
    T *V = _elem + lo; //调整指针
    for (Rank i = hi - lo; i > 0; i--)
        std::swap(V[i - 1], V[rand() % i]);
}

对应的，我们可以查询某个序列的逆序数：

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;
}

排序

排序算法是向量无序转有序的关键，该类算法多种多样，这里目前只实现比较简单的冒泡排序：

template <typename T>
void Vector<T>::sort(Rank lo, Rank hi)
{
    while (!bubble(lo, hi--))
        ; //当返回sorted=true时，停止扫描
}

下面我们实现扫描交换的算法：

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; //判断说明下次扫描可能还会出现逆序
            std::swap(_elem[lo - 1], _elem[lo]);
        }
    return sorted; //只有本次扫描没有出现逆序，则下次一定不会出现逆序，可终止扫描
}

插入与查找

插入单个元素，届时检查容量是否支持该次插入操作，不支持时需要扩容：

template <typename T>
Rank Vector<T>::insert(Rank r, T const &e)
{
    expand(); //若需要，先扩容
    for (int i = _size; i > r;)
        _elem[i] = _elem[i - 1]; //整体后移一位，从后向前
    _elem[r] = e;
    _size++;
    return r;
}

这是对于无序向量查找的实现，顺次查询：

template <typename T>
Rank Vector<T>::find(T const &e, Rank lo, Rank hi) const
{
    while ((lo < hi--) && (e != _elem[hi]))
        ; //当匹配到对应的e后停止，并返回秩
    return hi;
}

有序向量查找

二分查找是查找有序序列常见的思路，对于分切点的选取，我们给出两种策略：

  1. 区间中点作为切割点（三分支，比较两次）：
template <typename T>
static Rank binSearch(T *A, T const &e, Rank lo, Rank hi)
{
    while (lo < hi)
    {
        Rank mi = (lo + hi) >> 1; //取区间中点
        if (A[mi] > e)
            hi = mi; //若中点值大于目标值，转移至前驱区间[lo, mi)
        else if (A[mi] < e)
            lo = mi + 1; //若中点值小于目标值，转移至后继区间(mi, hi)
        else
            return mi; //若中点值等于目标值，返回中点的秩
    }
    return -1;
}

对该算法可行性的检验可以通过列举一些退化的例子，如只有三个元素：<、<、=或<、<、>，以及=、>、>和<、>、>。

需要注意的是，最后一个元素实际不参与比较或根本不存在，只是一个哨兵元素。

  1. 斐波拉契（黄金分割）分段点：

二分查找本质上是一种“减而治之”的查找策略，它并不约束查找中点（mi）的位置。我们可以按照黄金分割比来确定mi的位置：

设向量长度为 n = fib(k) - 1
在这里插入图片描述
算法的复杂度基本仅来源于中值的比较，这两种查找方式都是O(logn)级的时间复杂度。但准确来说，以黄金分割率确立的查找策略比前者优于一个常数级。

由于是三分支的查找，至少需要设置两次比较，若目标项在向量首段，则每次迭代需要进行一次比较；若在末段，则需比较两次（因为转向后继区间的代码位于else if，想要转向后继区间，必须先执行if段的代码，这是无法避免的）。

相比于等分策略，黄金分割策略加长了前驱区间（只需一次比较）的长度，即减少了需比较两次的情况，因此理论上性能更优。当然我们也有其他提升性能的方法，比如改进成两分支。

删除

区间批量删除：

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;                //返回删除元素的个数
}

单个删除操作：

template <typename T>
T Vector<T>::remove(Rank r)
{
    T re_elem = _elem[r]; //备份将被删除的元素
    remove(r, r + 1);
    return re_elem;
}

我们将区间批量删除作为单个删除的子操作，因为批量删除操作相比执行多次单个删除操作所需的时间成本更低。

去重

对于无序向量，只能逐次检查，每次删除一个重复元素：

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;
}

从前向后逐渐扩大查重范围。
无序向量去重
对于有序向量，我们有更方便的去重方式，因为元素都是依次排好的：

template <typename T>
int Vector<T>::uniquify() //有序向量去重
{
    Rank i = 0, j = 1;
    while (j < _size)
        (_elem[i] == _elem[j]) ? j++ : _elem[++i] = _elem[j++]; //查询到首个不重复元素并将其赋值到i的后继位置
    _size = ++i; //重新对规模赋值，未被覆盖的元素不做处理，或等到内存动态规划时删除
    shrink();  //装填因子过小时缩容
    return j - i;
}

从前向后依次检查，可批量的删除重复的元素：
有序向量去重
这里的删除并不是实际执行的操作，仅通过将不重复的元素赋值到一起，忽略重复的元素来实现。

遍历（批量）操作

我们为两种批量操作都提供了接口：

  1. 遍历向量，对每个元素执行函数指针提供的操作：
template <typename T>
void Vector<T>::traverse(void (*visit)(T &))
{
    for (int i = 0; i < _size; i++)
        visit(_elem[i]); //使用传入的函数指针处理
}
  1. 遍历向量，对每个元素执行函数对象（一种重载()操作符的特殊类，其实例对象可以像函数一样调用）提供的操作：
template <typename T>
template <typename VST>
void Vector<T>::traverse(VST &visit)
{
    for (int i = 0; i < _size; i++)
        visit(_elem[i]); //使用传入的函数对象处理
}

我们可以自定义函数指针和函数对象来执行批量的任务。

Jesse-Jo
关注
  • 3
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++中的向量_C ++中的向量
从零开始的教程世界
07-20 8018
c++中的向量A Vectors in C++ is an array-like container that can change dynamically in size. Being a part of the C++ STL, a Vector can support various dynamic array operations. C ++中的Vector是类似于数组的容器，可以动态改变...
C++中的向量
03-27
C++中的向量真乃神器也，什么？你还不知道，赶快来看吧
C++向量（Vector）
最新发布
dh3_zhang的博客
06-06 890
vector是C++中非常实用的动态数组类型，它提供了灵活且方便的方式来存储和操作元素。通过掌握其基本使用方法和常用操作，可以有效地利用vector来解决各种编程问题。选择使用数组还是vector取决于具体的应用场景和需求。如果数据量固定且不需要频繁地进行动态大小调整，且对访问速度有较高要求，那么数组可能是更好的选择。如果需要动态调整数据大小，且希望避免手动管理内存，那么vector可能是更好的选择。在实际应用中，可以根据具体需求权衡两者的优缺点，选择最适合的数据结构。
C++向量
iteye_14589的博客
05-20 178
//迭代就相当于枚举器 //向量相当于动态数组(NSMUtableArray) // #include &lt;iostream&gt; #include&lt;vector&gt; using namespace std; int main(int argc, const char * argv[]) { // insert code here... std:...
C++中的向量学习
weixin_30367169的博客
08-17 93
#include <iostream>#include <vector> //要包含这个头文件using namespace std;int main(void){ vector<int> a(10);//定义了10个整数元素的向量，但没有给出初值，因而，其值是不确定滴。 vector<int> b(10,1);//定义了10个证...
c++向量（vector）
qq_40934679的博客
09-16 1054
vector 概念 向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。 使用 引入头文件 #include<vector> 构造 vector<int>a; // 构造一个空的vector vector...
数据结构学习（C++）——后记.docx
12-07
STL提供了一些常见数据结构（如向量、链表、队列、栈）和排序、查找算法的实现，这可能导致学习者过分依赖现成的库，从而忽视了对数据结构底层实现的理解。作者提醒读者，学习数据结构的核心目标之一是理解“数据...
数据结构C++语言描述——应用标准模板库（STL）
12-06
在《数据结构C++语言描述——应用标准模板库（STL）》这本书中，你将深入学习如何利用STL来实现常见的数据结构，如堆、队列、栈等。作者可能通过实例演示了如何使用STL容器、算法和函数对象来解决实际问题，同时也...
c++数据结构-图
08-12
本篇将深入探讨C++中的一个关键数据结构——图。 图是一种非线性数据结构，由顶点（或节点）和边组成。在C++中，图可以用来表示网络、关系数据库、文件系统等多种复杂结构。图的数据结构可以分为两种主要类型：邻接...
hanshu.zip_数据结构_Visual_C++_
08-11
《数据结构与Visual C++：探索斐波那契序列的高效实现》 在计算机科学领域，数据结构和算法是核心部分，它们对于程序设计和问题解决至关重要。在本主题中，我们将聚焦于“hanshu.zip”压缩包中的“hanshu.cpp”文件...
CPP_struct_appendixB.rar_数据结构_Visual_C++_
08-12
《C++数据结构实战——Visual C++实现》 在编程领域，数据结构是核心概念之一，它涉及到如何高效地组织和存储数据以便于程序的处理。C++作为一门强大且广泛应用的编程语言，提供了丰富的工具来实现各种数据结构。本...
C++实现的向量运算
04-27
本程序简单的实现了向量的四则运算，基于VC++平台测试成功，希望大家下载！
c++向量模板(myVector)
11-27
自己写的一个向量模板类，大家可以参考学习一下。
c++向量
weixin_30825581的博客
12-30 3776
https://blog.csdn.net/suxiao_shaoer/article/details/52180087 vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的. 用法: 1.文件包含: 首先在程序开头处加上#include以包含所需要的类文件vector 还有一...
C++ 向量（vector）
february_的博客
12-06 8494
1. vector介绍 向量 vector 是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。 与string相同, vector 同属于STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型, 可以广义上认为是数组的增强版 ,与数组相比，vector就是一个可以不用再初始化就必须制定大小的边长数组，当然了，它还有许多高级功能。 ...
C++ 向量(vector)
lisayh的博客
02-15 7864
1.向量vector简介 向量 vector 是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。 与string相同, vector 同属于STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型, 可以广义上认为是数组的增强版。      在使用它时, 需要包含头文件 vector, #include&lt;vector&gt;  ...
[数据结构 C++(3)]：向量
shinezzz的博客
07-03 448
目录1. 数组到向量1. 数组2. 向量2. 接口3. 构造和析构4. 动态空间管理5. 常规向量6. 有序向量7. 排序器 1. 数组到向量 数据结构按照逻辑次序的复杂程度可以分为线性结构、半线性结构以及非线性结构。最为基本的线性结构统称为序列(sequence)，序列又可以分为向量(vector)和列表(list)。 1. 数组 数组(array)是C++和Java里的一种内置的数据类型，从0...
C++之向量
your_elephant的博客
05-10 2976
一、向量 向量vector是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。 与string相同, vector 同属于STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型, 可以广义上认为是数组的增强版。 在使用它时, 需要包含头文件 vector,#include<vector>，vector 容器与数组相...
C++入门：面向对象的类与数据结构——向量示例
在C++引论第六课中，我们深入探讨了面向对象编程的核心概念——类和数据结构，特别是通过实例化用户自定义数据类型来更好地理解和应用。课程的重点围绕着如何设计和实现一个代表几何向量的数据结构。 首先，几何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值