一、【数据结构】向量(vector)的实现

最新推荐文章于 2024-05-27 17:55:31 发布
最新推荐文章于 2024-05-27 17:55:31 发布
阅读量1.3k 收藏 14
点赞数 3
分类专栏： 数据结构 文章标签： vector 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18108083/article/details/84307865
版权

本文使用c++实现vector数据结构，vector的接口函数采用高效的实现方式，这样一方面使我加深对数据结构的理解，另一方便可以让我再回顾回顾c++，之前写了好久python都快把c++忘记了。

vector接口列表
操作功能对象
vector(int c, Rank s, T v)设置容量、初始大小、元素初始值 
vector(int c, Rank s)设置容量、初始大小 
vector(initializer_list<T>)列表初始化方式构造 
vector(const vector<T>& A, Rank lo, Rank hi)从另一vector拷贝构造新vector对象 
~vector()析构函数，手动释放动态数组所占的空间 
expand()容量更新(扩容)向量
sharink()容量更新(缩减)向量
display()打印vector内部元素向量
size()返回vector当前有效尺寸向量
get(Rank r)获取指定元素向量
put(Rank r, const T e)替换指定元素向量
permute()打乱vector顺序向量
unsort(Rank lo, Rank hi)打乱vector指定区间的顺序向量
find(Rank lo,Rank hi,const T e)在指定区间查找指定元素向量
insert(Rank r, const T& e)在指定区间插入元素向量
insert(const T& e)在尾部插入元素向量
remove(Rank lo, Rank hi)删除指定区间的元素向量
remove(Rank r)删除单个元素向量
deduplicate()除去重复元素向量
traverse(void(*func)(T& a))用指定函数批量处理元素(函数指针方式)向量
traverse(FunClass func)用指定函数批量处理元素(函数对象方式)向量
disordered()判断是不是有序向量向量
uniquify()除去重复元素有序向量
search(Rank lo, Rank hi, const T e)在指定区间中查找元素有序向量
binsearch(Rank lo, Rank hi, const T e)在指定区间中查找元素（二分查找）有序向量
sort(Rank lo, Rank hi, int a)排序算法汇总向量
bubbleSort(Rank lo, Rank hi)冒泡排序向量
mergeSort(Rank lo, Rank hi)归并排序向量
重载运算符[]下标运算符向量
重载运算符=赋值运算符向量
重载运算符=赋值运算符（列表赋值方式）向量
重载运算符==相等判断运算符向量
重载运算符<=小于等于判断运算符向量
重载运算符>=大于等于判断运算符向量
#pragma once
#define DEFAULT_CAPACITY 10 //默认容量大小
using namespace std;
typedef int Rank;

template <typename T>
class vector
{
protected:
	Rank _size;
	int _capacity;
	T *_elem; //vector内部所维护的数组的指针
public:
	//构造函数(容量,初始大小,初始值)
	vector(int c = DEFAULT_CAPACITY, Rank s = 0, T v = 0);
	vector(initializer_list<T>);    //列表初始化方式
	vector(const vector<T>& A, Rank lo, Rank hi);
	//析构函数
	~vector();

	//复制构造函数
	void copyFrom(const vector<T>& A, Rank lo, Rank hi);

	//容量更新(扩容和缩减)
	void expand();		
	void sharink();      

	//普通成员函数
	void display() const; //打印vector内部元素
	Rank size() const;    //返回vector当前size
	T get(Rank r);        //获取指定元素
	void put(Rank r, const T e);  //替换指定元素
	void permute();       //打乱顺序
	void unsort(Rank lo, Rank hi);  //打乱区间顺序
	Rank find(Rank lo,Rank hi,const T e);           //查找指定元素
	Rank insert(Rank r, const T& e); // 插入
	Rank insert(const T& e);       //在向量尾部插入
	int remove(Rank lo, Rank hi); //删除指定区间的元素
	T remove(Rank r);           //删除指定索引的单个元素
	void deduplicate();			  //除去重复元素
	void traverse(void(*func)(T& a));  //用指定函数批量处理元素(函数指针方式)
	template<typename FunClass> void traverse(FunClass func);             //用指定函数批量处理元素(函数对象方式)
	bool disordered() const;      //判断是不是有序向量
	void uniquify();              //有序向量除去重复元素
	Rank search(Rank lo, Rank hi, const T e); //有序向量，在指定区间中查找元素
	Rank search(const T e);
	Rank binsearch(Rank lo, Rank hi, const T e); //有序向量，二分查找
	void swap(T& a, T& b);        //交换元素值
	void sort(Rank lo, Rank hi, int a);    //排序算法汇总
	void bubbleSort(Rank lo, Rank hi);     //冒泡排序
	void mergeSort(Rank lo, Rank hi); //归并排序(递归实现)
	//重载运算符
	T& operator[](const Rank i) const;           //下标运算符
	vector<T>& operator=(const vector<T> &A);    //赋值运算符
	vector<T>& operator=(initializer_list<T>);   //赋值运算符，列表初始化
	bool operator==(const vector<T>& A);         //判等运算符
	bool operator<=(const vector<T>& A);         //小于等于判断
	bool operator>=(const vector<T>& A);         //大于等于判断
};

//实现c++中vector容器底层（具体实现也要放在与声明同样的文件中）

template <typename T> vector<T>::vector(int c, Rank s, T v)
{
	_elem = new T[_capacity = c];  //申请容量为T*c的内存空间并用_elem指针指向该地址
	for (_size = 0; _size < s; _elem[_size++] = v);  //对有效值进行初始化并更新_size
}

template<typename T> vector<T>::vector(initializer_list<T> li)
{
	_elem = new T[_capacity = li.size()];
	for (auto iter = li.begin(); iter != li.end(); iter++)
		_elem[_size++] = *iter;
}

template <typename T> vector<T>::vector(const vector<T>& A, Rank lo, Rank hi)
{
	copyFrom(A, lo, hi);
}


template <typename T> vector<T>::~vector()
{
	//释放数组中的空间
	delete[] _elem;
}

template <typename T> void vector<T>::copyFrom(const vector<T>& A, Rank lo, Rank hi)
{
	_capacity = (hi - lo) << 1;
	_size = 0;
	_elem = new T[_capacity];  //申请内存
	while (lo < hi)
	{
		_elem[_size++] = A[lo++];
	}
}

template<typename T> void vector<T>::display() const
{
	if (_size)
	{
		for (int i = 0; i < _size - 1; i++)
		{
			cout << _elem[i] << ",";
		}
		cout << _elem[_size - 1] << endl;
	}
}

//重载[]运算符
template<typename T> T& vector<T>::operator[](const Rank i) const
{
	return _elem[i];
}

template<typename T> vector<T>& vector<T>::operator=(const vector<T> &A)
{
	//释放之前的空间，后面会自动创建
	delete[] _elem;
	copyFrom(A, 0, A.size());
	return *this;  //返回this的引用才能连续赋值A=B=C
}

template<typename T> vector<T>& vector<T>::operator=(initializer_list<T> li)
{
	delete[] _elem;
	_size = 0;
	_capacity = li.size() << 1;
	_elem = new T[_capacity];  //申请内存
	for(auto iter=li.begin();iter!=li.end(); iter++)
		_elem[_size++] = *iter;

	return *this;
}

template<typename T> Rank vector<T>::size() const
{
	return _size;
}

template<typename T> T vector<T>::get(Rank r)   
{
	return _elem[r];
}

template<typename T> void vector<T>::put(Rank r, const T e)
{
	_elem[r] = e;
}

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


//{
//	//cout << "enpand():the old capacity: " << _capacity << endl;
//	if (_capacity < DEFAULT_CAPACITY) _capacity = DEFAULT_CAPACITY;
//	if ((_capacity >> 1) < _size) {  //如果_capacity不大于_size的两倍，扩容
//		T* tempPtr = new T[_capacity=(_size << 1)];
//		//cout << "_size" << _size << endl;
//		for(int i=0;i<_size;i++)
//		{
//			tempPtr[i] = _elem[i];  //转移数据
//			//cout << "i:" << i << endl;
//		}
//		delete[] _elem;  //清除之前的空间
//		_elem = tempPtr; //指针指向新的空间 
//	}
//	//cout << "enpand():the new capacity: " << _capacity << endl;
//}


template<typename T> void vector<T>::sharink()
{
	//cout << "sharink():the old capacity: " << _capacity << endl;
	if (_size < _capacity/4.0)   //_size小于_capacity的1/4，缩减
	{
		T *tempPtr = ((_size << 1) > DEFAULT_CAPACITY) ? new T[_capacity =(_size<<1)] : new T[_capacity = DEFAULT_CAPACITY];
		for (int i = 0; i < _size; i++)
		{
			tempPtr[i] = _elem[i];
			//cout << "i:" << i << endl;
		}
		delete[] _elem;
		_elem = tempPtr;   //更新指针指向
	}
	//cout << "sharink():the new capacity: " << _capacity << endl;

}

template<typename T> void vector<T>::permute()
{
	for(int i=0;i<_size;i++)
	{
		swap(_elem[i], _elem[rand()%_size]);   //随机找一个替换
	}
}


template<typename T> void vector<T>::unsort(Rank lo,Rank hi)
{
	for (int i = lo; i < hi; i++)
	{
		swap(_elem[i], _elem[rand() % (hi - lo) + lo]);
	}
}

template<typename T> bool vector<T>::operator==(const vector<T>& A)
{
	if (_size != A.size()) return false;
	for (int i = 0; i < _size; i++)
	{
		if(_elem[i] != A[i]) return false;
	}
	return true; 
}

template<typename T> bool vector<T>::operator<=(const vector<T>& A)
{
	int min = (_size <= A.size()) ? _size : A.size();
	for (int i = 0; i < min; i++)
	{
		if ((*this)[i] != A[i])
			return ((*this)[i] <= A[i]) ? true : false;
	}
	return (_size <= A.size()) ? true : false;
}

template<typename T> bool vector<T>::operator>=(const vector<T>& A)
{
	int min = (_size <= A.size()) ? _size : A.size();
	for (int i = 0; i < min; i++)
	{
		if ((*this)[i] != A[i])
			return ((*this)[i] >= A[i]) ? true : false;
	}
	return (_size >= A.size()) ? true : false;
}

template<typename T>  Rank vector<T>::find(Rank lo, Rank hi, const T e)  //	前闭后开
{

	while ((hi--)>lo)
	{
		if(_elem[hi] == e) break;
	}
	return hi;
}

template<typename T> Rank vector<T>::insert(Rank r, const  T& e)
{	
	expand();
	//Rank从r至以后的元素都要往后面移一位
	for (int i = _size; i > r; i--)
	{
		_elem[i] = _elem[i - 1];
	}
	_elem[r] = e;
	_size++;
	return r;
 }

template<typename T> Rank vector<T>::insert(const T& e)
{
	return insert(_size, e);
}

template<typename T> int vector<T>::remove(Rank lo, Rank hi)   //前闭后开
{
	//首先指定后界秩后面的元素都往前面移动(hi-lo+1)个位置,原位置置零
	if (lo == hi) return 0;
	while(hi<_size)
	{
		_elem[lo++] = _elem[hi];
		_elem[hi++] = 0;
	}
	//更新_size
	_size -= (hi - lo);
	sharink();
	return (hi - lo);
}

template<typename T> T vector<T>::remove(Rank r)
{
	T e = _elem[r];
	remove(r, r + 1);
	return e;
}

template<typename T> void vector<T>::deduplicate()
{
	if (!_size) return;

	Rank rl = 0;   //第rl个是已经确认无重的最后一个
	Rank rr = 1;   //第rr个是要判断的
	while (rr < _size)  // _size会减,rr会加
	{
		if (find(0, rl + 1, _elem[rr]) >= 0)    //确认是之前出现过
			remove(rr);
		else
		{
			rl++;       //加入一个有效值
			rr++;
		}
	}
}

template<typename T> void vector<T>::traverse(void(*func)(T& a))
{
	for (int i = 0; i < _size; i++)
	{
		func(_elem[i]);
	}
}

template<typename T> template<typename FunClass> void vector<T>::traverse(FunClass func)
{
	for (int i = 0; i < _size; i++)
	{
		func(_elem[i]);
	}
}


template<typename T> bool vector<T>::disordered() const
{
	for (int i = 0; i < _size - 1; i++)
	{
		if (_elem[i] > _elem[i + 1])
		{
			return false;
		}
	}
	return true;
}

template<typename T> void vector<T>::uniquify()
{
	if (_size<=1) return;
	Rank rl=0;    //已经确认好的序列的最后一个元素的秩
	Rank rr=1;    //正要判断的元素的秩
	while (rr < _size)
	{
		if (_elem[rr] != _elem[rr - 1])  //发现一个新值,移动到rl+1
		{
			_elem[++rl] = _elem[rr++];
		}
		else
			rr++;
	}
	_size = rl + 1;
	sharink();
}

template<typename T> Rank vector<T>::search(Rank lo, Rank hi, const T e)
{
	return binsearch(lo, hi, e);
}

template<typename T> Rank vector<T>::search(const T e)
{
	return (_size <= 0) ? -1 : search(0, _size, e);
}

template<typename T> Rank vector<T>::binsearch(Rank lo, Rank hi, const T e)    //  [0][1][2][m][4][5][6][7][-hi-]
{
	//方法一
	//把mi这一点作为一个分界线，单数直接作为右侧区间的左端点
	Rank mi;
	while (lo < hi)
	{
		mi = (lo + hi) >> 1;   //取中点的时候是往左偏的
		(e < _elem[mi]) ? hi = mi : lo = mi+1;     //都是左闭右开区间
	}
	return --lo;
}
																			   																																					   
//{   //方法二
//	Rank mi;
//	while (lo<hi)
//	{
//		mi = (lo + hi) >> 1;
//		if (_elem[mi] < e)
//			lo = mi + 1;
//		else if(_elem[mi] > e)
//			hi = mi;   //都是左闭右开区间
//		else
//			return mi;
//		}
//	return -1;
//}

template<typename T> void vector<T>::swap(T& a, T& b)
{
	a = a^b;      //原理:(a^b)^a=b
	b = a^b;
	a = a^b;  
}


template<typename T> void vector<T>::sort(Rank lo, Rank hi, int a)
{
	switch (a)
	{
		case 1:
			bubbleSort(lo, hi); break;   //冒泡排序
		case 2:;
			//selectSort(lo, hi); break;   //选择排序
		case 3:
			mergeSort(lo, hi); break;    //归并排序
		case 4:;
			//heapSort(lo, hi); break;     //堆排序
		default:;
			//quickSort(lo, hi); break;    //快速排序
	}
}

template<typename T> void vector<T>::bubbleSort(Rank lo, Rank hi)
{
	bool sorted = false;   //已有序标志
	while (!sorted)        //如果有序，提前退出
	{
		sorted = true;
		for (int i = lo; i < hi - 1; i++)  //在一次循环中如果发现逆序，就置标志位为false
		{
			
			if (_elem[i] > _elem[i + 1])
			{
				sorted = false;
				swap(_elem[i], _elem[i + 1]);
			}
			
		}
		hi--;
	}
}

template<typename T> void vector<T>::mergeSort(Rank lo, Rank hi)  //左闭右开区间
{
	if (!(lo < hi-1)) //只有一个元素则不用排序
		return;
	Rank mi = (lo + hi) >> 1;          //[0][1][2] [3]
	mergeSort(lo, mi);
	mergeSort(mi, hi);

	//开始归并
	T* A = _elem + lo;
	T* C = _elem + mi;
	int lb = mi - lo;  //1
	int lc = hi - mi;  //2
	T* B = new T[lb];  
	for (int i = 0; i < lb; i++)
		B[i] = A[i];    //复制元素到新空间
	//比较B和C所指序列的大小，将结果放置在A处
	for (int a=0, i = 0, j = 0; i < lb || j < lc;)
	{
		if (i < lb&&j < lc)       //两个序列都还有剩余
			A[a++] = (B[i] < C[j]) ? B[i++] : C[j++];
		if (i < lb && !(j < lc))  //只有B序列还有剩余
			A[a++] = B[i++];
		if (!(i < lb) && j < lc)  //只有C序列还有剩余
			A[a++] = C[j++];
	}
	delete[] B;  //有new就要有delete
}

 

csu_zhengzy~
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之向量的接口与实现(c++版)
xiangshawn的博客
03-28 418
文章目录 #1.前言 #2.向量接口定义 #3.向量接口实现 #4.向量功能检查 1.前言 下面来看看数据结构中最基础的向量的接口与实现 向量与数组类似，是一种线性数据结构，最基本的遍历向量的方式是寻秩访问，秩即向量每个元素的序号 下面我们用c++的语法定义向量的接口，并依次实现。在这里为了方便小白来看，我定义了只能装整数的向量。为了提高兼容性，可以参考范型程序设计的方法 例如： template...
纯c语言向量vector实现vector_master
06-27
为了在这些场景下也能实现类似的功能，我们可以自己编写一个纯C语言版本的向量（vector）数据结构。`vector_master`项目就是这样一个实现，它提供了C语言环境下向量的基本操作。 首先，让我们理解一下向量（vector...
数据结构-实现向量
cangzhexingxing的博客
05-12 87
#include<iostream> using namespace std; class Vector{ int cap; int sz; int* buf; public: Vector(){sz=0;cap=4;buf=new int[4];} Vector(int n,int v=0); Vector(const Vector &a){ //复制构造函数 buf=new int[a.cap]; sz=a.s.
C++详解------vector
最新发布
bububububuDDD的博客
05-27 982
vector的文档介绍vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。
数据结构-Vector实现（C++）
u011426979的专栏
01-08 458
#include using namespace std; template class Vector{ public:     //构造函数，初始化数组     Vector(int initSize = 0):theSize(initSize),theCapacity(initSize+SPARE_CAPACITY){         objects = new
数据结构之Vector
weixin_30423977的博客
10-22 104
最近看了邓俊辉版的《数据结构》，收获颇多，特将数据结构的实现以及一些算法在此进行整理，以强化记忆。 首先记录一下第一章Vector的实现以及选择排序、冒泡排序、合并排序等算法。 简单说一下看懂此源码的要求: 1. 简单掌握c++模板类 2. 对指针的实质掌握比较好 3. const的具体用法 4. 默认参数的使用 5. 简单的移位运算 6. 掌握c++中引用的实质 ...
数据结构——线性结构（9）——Vector的实现过程详解
redAnt的博客
10-22 1459
vector的基本操作及其特点在实现vector之前，我们都知道vector是可以储存任意类型的数值的。为了实现更一般的数据操作，我们当然是得要用模板类代替传统的实现。并且我们要实现[ ]的重载。头文件/* *这个文件包含我们Vector类的模板类的声明，vector是一个高效，方便，安全的数组替代品 */#ifndef _Vector_h #define _Vector_htemplate<t
c++实现向量运算.7z
04-09
首先，向量是具有大小（也称为模或长度）和方向的数据结构，通常表示为带有箭头的线段。在C++中，我们可以使用数组或标准模板库(STL)中的`std::vector`容器来表示向量。 1. **`std::vector`简介**：`std::vector`是...
向量 stl 数据结构
04-02
其中，向量（vector）是STL中非常重要的一个数据结构，它类似于动态数组，能够方便地进行增删改查操作。本章将详细讲解向量的基本概念、抽象数据类型、迭代器、实现方法以及一些实际应用。 2.1 向量的基本概念 向量...
用Java Vector向量实现线性表
07-02
在Java编程语言中，`Vector`类是Java集合框架的一部分，它被用来创建和管理动态数组，也就是一种线性数据结构。线性表是一种基本的数据结构，其中元素按顺序排列，每个元素都有一个前驱和后继（除了首元素和尾元素）...
Java 数据结构详细教程
08-23
栈实现了一个后进先出（LIFO）的数据结构。你可以把栈理解为对象的垂直分布的栈，当你添加一个新元素时，就将新元素放在其他元素的顶部。当你从栈中取元素的时候，就从栈顶取一个元素。最后进栈的元素最先被取出。栈...
数据结构学习笔记：向量之接口与实现
Peter_Red_Boy的博客
04-28 1642
向量vector属于一种线性数据结构 首先要清楚抽象数据类型（ADT）和数据结构的区别： 而向量这种结构就属于一种抽象数据类型，简称向量ADT，是数组的进化，是一种动态数组！！ 下面是vector数据结构类型的一些操作接口 以及这些向量接口的操作实例 ...
vector数据结构
qq_40078576的博客
06-30 1727
/*1.vector数据结构 vector和数组类似，拥有一段连续的内存空间，并且起始地址不变。 因此能高效的进行随机存取，时间复杂度为o(1); 但因为内存空间是连续的，所以在进行插入和删除操作时，会造成内存块的拷贝，时间复杂度为o(n)。 另外，当数组中内存空间不够时，会重新申请一块内存空间并进行内存拷贝。 2.list数据结构 list是由双向链表实现的，因此内存空间是不连续的。 只能通过指针访问数据，所以list的随机存取非常没有效率，时间复杂度为o(n); 但由于链表的特点，能高效地进行插入和删
数据结构与算法-vector实现
littleflypig的博客
11-13 705
本篇文章实现C++中的vector模板类 #include &amp;amp;amp;amp;lt;algorithm&amp;amp;amp;amp;gt; template &amp;amp;amp;amp;lt;typename object&amp;amp;amp;amp;gt; class myvector{ static const int SPARE_CAPACITY = 16; private: int size; int cap
数据结构One_Vector(向量的简单实现)
豆子
08-31 189
数据结构One_Vector(向量的简单实现) 1 #include <iostream> 2 using namespace std; 3 4 template<typename Object> 5 class Vector 6 { 7 private: 8 i...
数据结构-向量
u014291745的博客
02-17 1216
数据结构是数据项的结构化集合，其结构性表现为数据项之间的相互联系及作用，也可以理解为定义于数据项之间的某种逻辑次序。根据这种逻辑次序的复杂程度，大致可以将各种数据结构划分为线性结构、半线性结构与非线性结构三大类。在线性结构中，各数据项按照一个线性次序构成一个整体。最为基本的线性结构统称为序列（sequence），根据其中数据项的逻辑次序与其物理存储地址的对应关系不同，又可进一步地将序列区分为向量（
数据结构——向量
weixin_46351194的博客
11-01 796
与
c++ vector详解
m0_37949220的博客
04-20 537
目录1 底层结构2 构造函数3 访问方式4 常用函数sort函数 1 底层结构 vector底层的数据结构为顺序数组，vector有两个表示容量的指标，一个是size，一个是capacity，size表示当前数组中元素个数，capacity可以理解为连续空间的大小，capacity的大小是成倍增长的。 例如，若当前size=10，capacity也为10，再添加一个元素时，由于连续空间不够，需要将...
vector 简单底层实现
Cross
10-31 2212
代码： #include #include #include using namespace std; template class Vector{ private : T* data; /// 动态数组 指针指向一个内存空间 int len; /// 当前存在元素个数 int sz; /// 当前动态数组的大小 public : Vector(){
向量（vector）的数据结构（物理结构）的定义
03-18
向量（vector）是一种线性结构，它可以存储一系列具有相同数据类型的元素。在物理结构上，向量通常使用连续的内存空间来存储元素，这使得通过索引可以快速访问和修改元素。 向量的定义包括以下几个要素： 1. 存储空间：向量使用一块连续的内存空间来存储元素，这使得元素在内存中的存储位置是相邻的。 2. 元素类型：向量中的元素类型是相同的，可以是基本数据类型（如整数、浮点数等）或自定义的数据类型（如结构体、类等）。 3. 大小：向量的大小表示它可以容纳的元素数量，可以动态调整或固定大小。 4. 索引：向量中的每个元素都有一个唯一的索引，用于标识元素在向量中的位置。索引通常从0开始，依次递增。 向量的物理结构使得在访问和修改元素时具有较高的效率，因为可以通过索引直接计算出元素在内存中的地址。此外，向量还提供了一些常用的操作，如插入、删除、查找等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值