C++——STL之vector, list, deque容器对比与常用函数

STL 三种顺序容器的特性对比:

• vector 可变数组，内存空间是连续的，容量不会进行缩减。支持高效随机存取，即支持[]和at()操作。尾部插入删除效率高，其他位置插删效率较低；
• list 双向链表，内存空间可不连续，不支持随机存取。插入和删除的效率很高；
• deque  双端队列，内存空间是多个连续的内存块，在一个映射结构中保存对这些块以及顺序的跟踪，可利用的内存更大，且内存大小是可以自动缩减的。支持随机存取，但是随机存取性能没有vector 好。首尾插入效率高，其他位置插删效率低；

使用注意：

• 对于 vector 和 deque，使用随机访问时注意不要越界；
• 对于 vector 的非尾部插入删除和 deque的非首尾插入删除，会导致部分元素的移动，这是需要考虑之前正在用的迭代器、指针或索引是否需要调整；

 

vector 容器常用函数

vector 容器常用函数：

#构造：  
vector():                       #创建一个空vector  
vector(int nSize):              #创建一个vector,元素个数为nSize  
vector(int nSize,const t& t):   #创建一个vector，元素个数为nSize,且值均为t  
vector(const vector&):          #复制构造函数  
vector(begin,end):              #复制[begin,end)区间内另一个数组的元素到vector中  
#增删：  
void push_back(const T& x):                    #向量尾部增加一个元素X  
iterator insert(iterator it,const T& x):       #向量中迭代器指向元素前增加一个元素x  
iterator insert(iterator it,int n,const T& x): #向量中迭代器指向元素前增加n个相同的元素x  
iterator insert(iterator it,const_iterator first,const_iterator last): #向迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据  
iterator erase(iterator it):                   #删除向量中迭代器指向元素  
iterator erase(iterator first,iterator last):  #删除向量中[first,last)中元素  
void pop_back():                               #删除向量中最后一个元素  
void clear():                                  #清空向量中所有元素  
#遍历：  
reference at(int pos):      #返回pos位置元素的引用  
reference front():          #返回首元素的引用  
reference back():           #返回

 

List容器常用函数

#构造：  
list<Elem> c:           #创建一个空的list  
list<Elem> c1(c2):      #复制另一个同类型元素的list  
list<Elem>c(n):         #创建n个元素的list，每个元素值由默认构造函数确定  
list<Elem>c(n,elem):    #创建n个元素的list，每个元素的值为elem  
list<Elem>c(begin,end): #由迭代器创建list,迭代区间为[begin,end)  
#增删：  
void push_back(const T& x):     #尾部增加一个元素x  
void push_front(const T& x):    #首部添加一个元素X  
void pop_back():                #删除容器尾元素，当且仅当容器不为空  
void pop_front():               #删除容器首元素，当且仅当容器不为空  
void remove(const T& x):        #删除容器中所有元素值等于x的元素  
void clear():                   #删除容器中的所有元素  
iterator insert(iterator it, const T& x ):       #在迭代器指针it前插入元素x,返回x迭代器指针  
void insert(iterator it,size_type n,const T& x): #迭代器指针it前插入n个相同元素x  
void insert(iterator it,const_iterator first,const_iteratorlast):  #把[first,last)间的元素插入迭代器指针it前  
iterator erase(iterator it):                     #删除迭代器指针it对应的元素  
iterator erase(iterator first,iterator last):    #删除迭代器指针[first,last)间的元素  
#遍历：  
iterator begin():            #返回首元素的迭代器指针  
iterator end():              #返回尾元素之后位置的迭代器指针  
reverse_iterator rbegin():   #返回尾元素的逆向迭代器指针，用于逆向遍历容器  
reverse_iterator rend():     #返回首元素前一个位置的迭代器指针  
reference front():           #返回首元素的引用  
reference back():            #返回尾元素的引用   
#功能：  
void sort():                             #容器内所有元素排序，默认是升序  
template<class Pred>void sort(Pred pr):  #容器内所有元素根据预断定函数pr排序  
void swap(list& str):                    #两list容器交换功能  
void unique():                           #容器内相邻元素若有重复的，则仅保留一个  
void splice(iterator it,list& li):                #队列合并函数，队列li所有函数插入迭代指针it前，x变成空队列  
void splice(iterator it,list& li,iterator first): #队列li中移走[first,end)间元素插入迭代指针it前  
void splice(iterator it,list& li，iterator first,iterator last): #x中移走[first,last)间元素插入迭代器指针it前  
void reverse():                          #反转

Deque容器常用函数

#构造  
deque():                     #创建一个空deque  
deque(int nSize):            #创建一个deque,元素个数为nSize  
deque(int nSize,const T& t): #创建一个deque,元素个数为nSize,且值均为t  
deque(const deque &):        #复制构造函数  
#增删：  
void push_front(const T& x):                  #双端队列头部增加一个元素X  
void push_back(const T& x):                   #双端队列尾部增加一个元素x  
iterator insert(iterator it,const T& x):      #双端队列中某一元素前增加一个元素x  
void insert(iterator it,int n,const T& x):    #双端队列中某一元素前增加n个相同的元素x  
void insert(iterator it,const_iterator first,const_iteratorlast):  #双端队列中某一元素前插入另一个相同类型向量的[forst,last)间的数据  
iterator erase(iterator it):                  #删除双端队列中的某一个元素  
iterator erase(iterator first,iterator last): #删除双端队列中[first,last）中的元素  
void pop_front():                             #删除双端队列中最前一个元素  
void pop_back():                              #删除双端队列中最后一个元素  
void clear():                                 #清空双端队列中最后一个元素  
#遍历：  
reference at(int pos):          #返回pos位置元素的引用  
reference front():              #返回手元素的引用  
reference back():               #返回尾元素的引用  
iterator begin():               #返回向量头指针，指向第一个元素  
iterator end():                 #返回指向向量中最后一个元素下一个元素的指针（不包含在向量中）  
reverse_iterator rbegin():      #反向迭代器，指向最后一个元素  
reverse_iterator rend():        #反向迭代器，指向第一个元素的前一个元素  
#功能：  
bool empty() const:             #向量是否为空，若true,则向量中无元素  
int size() const:               #返回向量中元素的个数  
int max_size() const:           #返回最大可允许的双端对了元素数量值  
void swap(deque&):              #交换两个同类型队列的数据  
void assign(int n,const T& x):  #向量中第n个元素的值设置为x  

 

七、各种容器总结

(1) vector
内部数据结构：数组。
随机访问每个元素，所需要的时间为常量。
在末尾增加或删除元素所需时间与元素数目无关，在中间或开头增加或删除元素所需时间随元素数目呈线性变化。
可动态增加或减少元素，内存管理自动完成，但程序员可以使用reserve()成员函数来管理内存。
vector的迭代器在内存重新分配时将失效（它所指向的元素在该操作的前后不再相同）。当把超过capacity()-size()个元素插入vector中时，内存会重新分配，所有的迭代器都将失效；否则，指向当前元素以后的任何元素的迭代器都将失效。当删除元素时，指向被删除元素以后的任何元素的迭代器都将失效。

(2)deque
内部数据结构：数组。
随机访问每个元素，所需要的时间为常量。
在开头和末尾增加元素所需时间与元素数目无关，在中间增加或删除元素所需时间随元素数目呈线性变化。
可动态增加或减少元素，内存管理自动完成，不提供用于内存管理的成员函数。
增加任何元素都将使deque的迭代器失效。在deque的中间删除元素将使迭代器失效。在deque的头或尾删除元素时，只有指向该元素的迭代器失效。

(3)list
内部数据结构：双向环状链表。
不能随机访问一个元素。
可双向遍历。
在开头、末尾和中间任何地方增加或删除元素所需时间都为常量。
可动态增加或减少元素，内存管理自动完成。
增加任何元素都不会使迭代器失效。删除元素时，除了指向当前被删除元素的迭代器外，其它迭代器都不会失效。

(4)slist
内部数据结构：单向链表。
不可双向遍历，只能从前到后地遍历。
其它的特性同list相似。

(5)stack
适配器，它可以将任意类型的序列容器转换为一个堆栈，一般使用deque作为支持的序列容器。
元素只能后进先出（LIFO）。
不能遍历整个stack。

(6)queue
适配器，它可以将任意类型的序列容器转换为一个队列，一般使用deque作为支持的序列容器。
元素只能先进先出（FIFO）。
不能遍历整个queue。

(7)priority_queue
适配器，它可以将任意类型的序列容器转换为一个优先级队列，一般使用vector作为底层存储方式。
只能访问第一个元素，不能遍历整个priority_queue。
第一个元素始终是优先级最高的一个元素。

(8)set
键和值相等。
键唯一。
元素默认按升序排列。
如果迭代器所指向的元素被删除，则该迭代器失效。其它任何增加、删除元素的操作都不会使迭代器失效。

(9)multiset
键可以不唯一。
其它特点与set相同。

(10)hash_set
与set相比较，它里面的元素不一定是经过排序的，而是按照所用的hash函数分派的，它能提供更快的搜索速度（当然跟hash函数有关）。
其它特点与set相同。

(11)hash_multiset
键可以不唯一。
其它特点与hash_set相同。

(12)map
键唯一。
元素默认按键的升序排列。
如果迭代器所指向的元素被删除，则该迭代器失效。其它任何增加、删除元素的操作都不会使迭代器失效。

(13)multimap
键可以不唯一。
其它特点与map相同。

(14)hash_map
与map相比较，它里面的元素不一定是按键值排序的，而是按照所用的hash函数分派的，它能提供更快的搜索速度（当然也跟hash函数有关）。
其它特点与map相同。

(15)hash_multimap
键可以不唯一。
其它特点与hash_map相同。
 

参考：https://blog.csdn.net/yinghuoai/article/details/79509309 

参考：https://blog.csdn.net/hlsdbd1990/article/details/46664751