c++容器list与vector差异浅析

·前言

c++对于c语言的改进，除了给予其OPP属性以外，还有一点便是引入了标准化模板库（Standard Template Library）。而可能我们使用最平凡的便是vector与list两种。作为初学者最容易分不清的便是这两种，容易产生的问题有如下几种：
1.为什么我使用vector可以直接用下标访问而list却不行？
2.为什么list迭代器不能直接加减数字？该问题即为：为什么我删除/插入某一个元素时list不能直接使用 listA.begin()+num的形式？
3.既然我用vector可以实现几乎链表的一切操作那我为什么还要用链表？
以下，笔者将会尽自己所能给出解答。请耐心看完全文，之后才会对所有问题进行总结。

·vector与list的实现原理

如果将vector这一概念映射到c中，那么vector实际上便是c99当中的VLA（变长数组）的优良改进版，它使得我们可以能够随时更改一个数组的长度。其实现原理是在最开始的声明的时候便会划分一块单独的较大内存空间，作为向量的capacity(容量)，这些内存空间都属于改vector对象，并会随着元素的增多而指数增大。向量并不是链表，这也意味着它在每次增删元素的时候会有移动整个数组的风险。
而c++STL中的list的实现方式更近似于双向链表，是一种线性表。此处不再多说。
接下来是一个实例：

#include <iostream>
#include <cstdio>
#include <list>
#include <vector>
#include <algorithm>
using namespace std;
int show(vector<int> &v1);//可重载的show函数
int show(list<int> &list1);
int main(void)
{
	int a[9] = { 1,2,3,4,5,};
	vector<int> VECTOR(&a[0],&a[5]);//初始化一个向量
	list<int> LIST(&a[0], &a[5]);//初始化一个链表
	cout << "The Origin VECTOR:" << endl;
	show(VECTOR);
	cout << "The Origin LIST:" << endl;
	show(LIST);
	VECTOR.erase( find(VECTOR.begin(), VECTOR.end(), 3)  );//find是<algorithm>所提供的函数，其作用是找到匹配的元素并返回迭代器
	cout << "After Deleting 3 from VECTOR:" << endl;
	show(VECTOR);
	LIST.erase(find(LIST.begin(), LIST.end(), 3));
	cout << "After Deleting 3 from LIST:" << endl;
	show(LIST);
	return 0;
}
int show(vector<int> &v1)
{
	int len = v1.size();
	for (int i = 0; i < len; i++)
		printf("v1[%d]=%d  pointer=0X%x\n", i, v1[i], &v1[i]);
	printf("\n\n");
	return 0;
}
int show(list<int> &list1)
{
	int len = list1.size();
	list<int>::iterator it=list1.begin();
	for (int i = 0; i < len; i++, it++)
	{
		int& num = *it;//新建引用型变量打印地址
		printf("list1[%d]=%d  pointer=0X%x\n", i, *it, &num);
	}
	printf("\n\n");
	return 0;
}

运行实例：

The Origin VECTOR:
v1[0]=1  pointer=0X3b62a8
v1[1]=2  pointer=0X3b62ac
v1[2]=3  pointer=0X3b62b0
v1[3]=4  pointer=0X3b62b4
v1[4]=5  pointer=0X3b62b8


The Origin LIST:
list1[0]=1  pointer=0X3bebf8
list1[1]=2  pointer=0X3be9c8
list1[2]=3  pointer=0X3bedb8
list1[3]=4  pointer=0X3beb50
list1[4]=5  pointer=0X3beb88


After Deleting 3 from VECTOR:
v1[0]=1  pointer=0X3b62a8
v1[1]=2  pointer=0X3b62ac
v1[2]=4  pointer=0X3b62b0
v1[3]=5  pointer=0X3b62b4


After Deleting 3 from LIST:
list1[0]=1  pointer=0X3bebf8
list1[1]=2  pointer=0X3be9c8
list1[2]=4  pointer=0X3beb50
list1[3]=5  pointer=0X3beb88

·分析

从上面我们可以看出向量在内存中是连续存放的，并且它会一直保证所有数据是连续存储的。而链表则不同，它并不会所以这意味着。当我们从中删去一个元素时，往往向量将会作出更大的空间上的变化？那么：明明它们的作用是一样的，那我为什么不使用更简单的向量呢？
我们接下来将进行探索，对于一个vector于list的速度有什么区别。操作是在第一个元素与第二个元素之间插入元素（这是一个普通的操作）

#define MAX 100000
int main(void)
{
	int a[3] = { 1,MAX };
	vector<int> VECTOR(&a[0],&a[2]);//初始化一个向量
	list<int> LIST(&a[0], &a[2]);//初始化一个链表
	int start=clock(),end;
	for (int i = MAX-1; i >1; i--)
		VECTOR.insert(VECTOR.begin()+1,i);
	end = clock();//调用了ctime库函数，作用是返回当前系统时间
	cout << "VECTOR Time=" << end - start <<"ms"<< endl;
	start = clock();
	for (int i = MAX-1; i>1; i--)
		LIST.insert(++LIST.begin(),i);
	end = clock();
	cout << "LIST Time=" << end - start <<"ms"<< endl;
	return 0;
}

这是MAX=1e5的情形

当MAX=3e5

因为每一次插入元素时，向量必须得将所有在它之后的元素往后位移一个，所以插入操作对于向量来说复杂度会随元素数量而提高。所以当我们涉及到的操作具有频繁插入数据时，我们就应该选择链表这一数据结构。
PS：有趣的是由于泛型编程这一概念是STL所恪守的原则，所以vector的行为中删去了pop_front这一操作

小结

向量是一种具有O1访问的结构，而list是具有O1插入的结构，他们在本质上是数组与链表的关系。
下面是一张完整的内容

部分引自：jgl841001
https://blog.csdn.net/jgl841001/article/details/8181933
 

向量vector
可以用常数时间访问和修改任意元素，在序列尾部进行插入和删除时，具有常数时间复杂度，对任意项的插入和删除就有的时间复杂度与到末尾的距离成正比，尤其对向量头的添加和删除的代价是惊人的高的
迭代器是否可以自增减：可以
迭代器是否可以与整数相加：可以

双端队列deque

基本上与向量相同，唯一的不同是，其在序列头部插入和删除操作也具有常量时间复杂度
迭代器是否可以自增减：可以
迭代器是否可以与整数相加：可以

表list

对任意元素的访问与对两端的距离成正比，但对某个位置上插入和删除
迭代器是否可以自增减：可以
迭代器是否可以与整数相加：不可以

队列queue

插入只可以在尾部进行，删除、检索和修改只允许从头部进行。按照先进先出的原则。
queue没有迭代器！不支持遍历以及中间插入。

堆栈stack

堆栈是项的有限序列，并满足序列中被删除、检索和修改的项只能是最近插入序列的项。即按照后进先出的原则
stack没有迭代器！不支持遍历以及中间插入。

集合set

由节点组成的红黑树，每个节点都包含着一个元素，节点之间以某种作用于元素对的谓词排列，没有两个不同的元素能够拥有相同的次序，具有快速查找的功能。但是它是以牺牲插入插入删除操作的效率为代价的
迭代器是否可以自增减：可以
迭代器是否可以与整数相加：不可以

我们在上面的代码块中的14行可以看到一个有趣的现象，就是我们要将迭代器指向第二号元素时我们对其进行了前缀自增1。原因就是困扰很多人的一个问题：为什么list的迭代器不能直接加减？
其实原因很简单，因为list的寻址访问并不是O1级别，它必须得经过遍历才能到达指定元素。因此STL删去了对list迭代器的重载
但我们仍然可以对其重载：

list<int>::iterator operator +(const list<int>::iterator &it, int i)
{
	list<int>::iterator _it = it;
	for (int count = 0; count < i; count++, _it++);
	return _it;
}

同理我们也可以对数组预算符 [] 进行重载，此处不给出例子
最后回答最开始提出的三个问题：
1.为什么我使用vector可以直接用下标访问而list却不行？
因为list是线性表，储存不具有连续的性质，不能做到O1访问，故不能直接下标计算得出地址并访问
2.为什么list迭代器不能直接加减数字？该问题即为：为什么我删除/插入某一个元素时list不能直接使用 listA.begin()+num的形式？
同上
3.既然我用vector可以实现几乎链表的一切操作那我为什么还要用链表？
vector的插入操作复杂度较高，并且会随数据量上升而上升