C++ vector、list和deque的区别 （整理）

1.vector数据结构
　　vector和数组类似，拥有一段连续的内存空间，并且起始地址不变。因此能高效的进行随机存取，时间复杂度为o(1);但因为内存空间是连续的，所以在进行插入和删除操作时，会造成内存块的拷贝，时间复杂度为o(n)。另外，当数组中内存空间不够时，会重新申请一块内存空间并进行内存拷贝。

vector实现原理：

　　STL内部实现时，首先分配一个非常大的内存空间预备进行存储，即capacity（）函数返回的大小，当超过此分配的空间时再整体重新放分配一块内存存储（VS6.0是两倍，VS2005是1.5倍），所以这给人以vector可以不指定vector即一个连续内存的大小的感觉。通常此默认的内存分配能完成大部分情况下的存储。

扩充空间（不论多大）都应该这样做：
   （1）配置一块新空间
   （2）将旧元素一一搬往新址
   （3）把原来的空间释放还给系统

　　注：vector 的数据安排以及操作方式，与array 非常相似。两者的唯一差别在于空间的利用的灵活性。Array 的扩充空间要程序员自己来写。

　vector类定义了好几种构造函数，用来定义和初始化vector对象:
    vector<T>  v1;  vector保存类型为T的对象。默认构造函数v1为空。
    vector<T> v2(v1);  v2是v1的一个副本。
    vector<T> v3(n, i);  v3包含n个值为i的元素。
    vector<T> v4(n);   v4含有值初始化的元素的n个副本。

2.list数据结构

　　非连续存储结构，具有双向链表结构，每个元素维护一对前向和后向指针，因此支持前向/后向遍历。支持高效的随机插入/删除操作，但随机访问效率低下，且由于需要额外维护指针，开销也比较大。每一个结点都包括一个信息快Info、一个前驱指针Pre、一个后驱指针Post。可以不分配必须的内存大小方便的进行添加和删除操作。使用的是非连续的内存空间进行存储。

优点：(1) 不使用连续内存完成动态操作。
               (2) 在内部方便的进行插入和删除操作
               (3) 可在两端进行push、pop
   缺点：(1) 不能进行内部的随机访问，即不支持[ ]操作符和vector.at()
               (2) 相对于verctor占用内存多

3.deque数据结构

　　连续存储结构，即其每个元素在内存上也是连续的，类似于vector，不同之处在于，deque提供了两级数组结构， 第一级完全类似于vector，代表实际容器；另一级维护容器的首位地址。这样，deque除了具有vector的所有功能外，还支持高效的首/尾端插入/删除操作。
    deque   双端队列 double-end queue
    deque是在功能上合并了vector和list。
    优点：(1) 随机访问方便，即支持[ ]操作符和vector.at()
                (2) 在内部方便的进行插入和删除操作
                (3) 可在两端进行push、pop
    缺点：占用内存多
   使用区别：
     （1）如果你需要高效的随即存取，而不在乎插入和删除的效率，使用vector
     （2）如果你需要大量的插入和删除，而不关心随机存取，则应使用list
     （3）如果你需要随机存取，而且关心两端数据的插入和删除，则应使用deque

4、vector VS. list VS. deque：
    a、若需要随机访问操作，则选择vector；
    b、若已经知道需要存储元素的数目，则选择vector；
    c、若需要随机插入/删除（不仅仅在两端），则选择list
    d、只有需要在首端进行插入/删除操作的时候，还要兼顾随机访问效率，才选择deque，否则都选择vector。
    e、若既需要随机插入/删除，又需要随机访问，则需要在vector与list间做个折中-deque。
    f、当要存储的是大型负责类对象时，list要优于vector；当然这时候也可以用vector来存储指向对象的指针，
       同样会取得较高的效率，但是指针的维护非常容易出错，因此不推荐使用。

问题一：list和vector的区别：
（1）vector为存储的对象分配一块连续的地址空间，随机访问效率很高。但是插入和删除需要移动大量的数据，效率较低。尤其当vector中存储
的对象较大，或者构造函数复杂，则在对现有的元素进行拷贝的时候会执行拷贝构造函数。
（2）list中的对象是离散的，随机访问需要遍历整个链表，访问效率比vector低。但是在list中插入元素，尤其在首尾插入，效率很高，只需要改变元素的指针。

（3）vector是单向的，而list是双向的；

（4）vector中的iterator在使用后就释放了，但是链表list不同，它的迭代器在使用后还可以继续用；链表特有的；

使用原则：
（1）如果需要高效的随机存取，而不在乎插入和删除的效率，使用vector；
（2）如果需要大量高效的删除插入，而不在乎存取时间，则使用list；
（3）如果需要高效的随机存取，还要大量的首尾的插入删除则建议使用deque，它是list和vector的折中；

问题二：常量容器const
     const vector<int> vec(10);//这个容器里capacity和size和值都是不能改变的，const修饰的是vector；
     迭代器：const vector<int>::const_iterrator ite; //常量迭代器；
      注：const vector <int> vec(10) —— 与const int a[10]是一回事，意思是vec只有10个元素，不能增加了，里面的元素也是不能变化的

问题三：capacity V.S size
    a、capacity是容器需要增长之前，能够盛的元素总数；只有连续存储的容器才有capacity的概念（例如vector，deque，string），list不需要capacity。
    b、size是容器当前存储的元素的数目。
    c、vector默认的容量初始值，以及增长规则是依赖于编译器的。

问题四：用vector存储自定义类对象时，自定义类对象须满足：
    a、有可供调用的无参构造函数（默认的或自定义的）；

b、有可用的拷贝赋值函数（默认的或自定义的）

 ite=find(vec.begin(),vec.end(),);
 vec.insert(ite,,);  //迭代器标记的位置前，插入2个77；
 cout<<*ite<<endl;  //会崩溃，因为迭代器在使用后就释放了，*ite的时候就找不到它的地址了； 

 #include <iostream>
 using namespace std;
 #include <vector>   //向量的头文件；
 #include <algorithm> //算法的头文件；
 int main()
 {
     vector <int> vec(,);
     //--类型是vector<int>，该容器向量中含有5个int类型的数值8，变量名为vec。
     //vector是一个类模板（class template）,所以必须要声明其类型，int，一个容器中所有的对象必须是同一种类型；
     // 定义一个容器对象；直接构造出一个数组；用法和数组一样；
     //
         for(int i=;i<vec.size();i++)   //size()是指容器里当前有多少个使用的元素；
         {
             cout<<vec[i]<<"  ";
         }
         cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;  //得到容器里用的多少个空间，和总共的大小；
      vector<int>::iterator ite;  //定义了一个向量的迭代器；相当于定义了一个指针；
     for(ite=vec.begin();ite!=vec.end();ite++)   //得到开始、结束
     {
         cout<<*ite <<" ";  //迭代器返回的是引用：
     }
         cout<<endl;
     //在尾部插入；
     vec.push_back();  //VS6.0扩充的空间是两倍；在VS2005扩充的空间是1.5倍；
     for(ite=vec.begin();ite!=vec.end();ite++)   //得到开始、结束
     {
         cout<<*ite <<" ";
     }
     cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;  

     //尾部删除;容量没变【capacitty】，但是使用空间减少一个；容量一旦增加就不会减小；
     vec.pop_back();
     for(ite=vec.begin();ite!=vec.end();ite++)   //得到开始、结束
     {
         cout<<*ite <<" ";
     }
     cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;  

     vec.push_back();
     vec.push_back(); //容量刚好够；  

     for(ite=vec.begin();ite!=vec.end();ite++)   //得到开始、结束
     {
         cout<<*ite <<" ";
     }
     cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;  

     ite = find(vec.begin(),vec.end(),);   //查找这个元素；
     vec.erase(ite);  //利用迭代器指针删除这个元素；
     for(int i=;i<vec.size();i++)   //size()是指容器里当前有多少个使用的元素；
     {
         cout<<vec[i]<<" ";
     }
     cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;  //得到容器里用的多少个空间，和总共的大小；  

     vec.clear(); //只是清除了数据，没有回收空间，空间的等到对象的生命周期结束时回收；
     //使用空间为0，但是容量的空间还在，只有在调用析构函数的时候空间才会回收；  

     for(int i=;i<vec.size();i++)   //size()是指容器里当前有多少个使用的元素；
     {
         cout<<vec[i]<<"  ";
     }
     cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;  

     ite=find(vec.begin(),vec.end(),);
     vec.insert(ite,,);  //迭代器标记的位置前，插入数据；  

     //cout<<*ite<<endl;  //会崩溃，因为迭代器在使用后就释放了，*ite的时候就找不到它的地址了；
     //和向量的用法一样，但是链表list不同，它的迭代器在使用后还可以继续用；链表特有的；</span>  

     for(int i=;i<vec.size();i++)
     {
         cout<<vec[i]<<"  ";
     }
     cout<<endl<<vec.size()<<" "<<vec.capacity()<<endl;  

     system("pause");
     return ;
 }  

运行结果如下：

List代码示例：

 #include<iostream>
 #include <list>
 #include <algorithm>
 using namespace  std;
 int main()
 {
     list<char> lit;
     //用法和向量一样，
     //list是一个类模板，template，char是链表里对象的类型，lit是创建的一个对象；
     //链表可以再头尾两端插入,是双向的；  

     lit.push_back('a');
     lit.push_back('b');
     lit.push_front('d');
     lit.push_front('e');
     lit.push_front('f');
     lit.push_front('b');
     lit.push_front('b');  

     list<char>::iterator it;  //定义一个list的迭代器，类似一个纸箱链表的指针，但是比一般的指针好用，里面用到了好多重载操作；
     list<char>::iterator it1;
     list<char>::iterator it2;
     for(it=lit.begin();it!=lit.end();it++)
     {
         cout<<*it<<"  ";
     }
     cout<<endl;
     //-----------链表可以从两端删除-------------------
     lit.pop_back();
     lit.pop_front();
     for(it=lit.begin();it!=lit.end();it++)
     {
         cout<<*it<<"  ";
     }
     cout<<endl;
     //-------------删除所有的a---------------------------------
     //lit.remove('a');  //删除所有的a;  

     for(it=lit.begin();it!=lit.end();it++)
     {
         cout<<*it<<"  ";
     }
     cout<<endl;
     //-------------移除连续且相同的a，只剩下一个;--------------------------------
     lit.unique();  //移除连续且相同的a，只剩下一个;  

     for(it=lit.begin();it!=lit.end();it++)
     {
         cout<<*it<<"  ";
     }
     cout<<endl;
     list<char> lit1;
     lit1.push_back('g');
     lit1.push_back('h');
     lit1.push_back('i');
     lit1.push_back('k');
     for(it1=lit1.begin();it1!=lit1.end();it1++)
     {
         cout<<*it1<<"  ";
     }
     cout<<endl;
     //-------------将一个链表插入到另一个链表---------------------------------
     it1=find(lit.begin(),lit.end(),'f');  //先的找到要插入的位置，在该位置的前一个插入；
     ////lit.splice(it1,lit1); //将第二个链表插入到第一个链表中；合并后的链表就没了，因为传的是&；
     for(it=lit.begin();it!=lit.end();it++)
     {
         cout<<*it<<"  ";
     }
     cout<<endl;
     //------在链表lit中的it前插入lit1中的一个元素it1；在f之前插入k-----
     //-----拿下来之后那个元素就没有了-------------------
     it=find(lit.begin(),lit.end(),'f');
     it1=find(lit1.begin(),lit1.end(),'k');
     lit.splice(it,lit1,it1);
     //-------------把链表中的一段插入到另一个链表中---------------------------------
     //把链表lit1中的[it-----it1)段的字符插入到lit的it2指针前；
     it=find(lit1.begin(),lit1.end(),'h');
     it1=find(lit1.begin(),lit1.end(),'k');
     it2=find(lit.begin(),lit.end(),'f');
     lit.splice(it2,lit1,it,it1);
     // ----void merge(list& x); //将x合并到*this 身上。两个lists 的内容都必须先经过递增归并排序。
     lit.sort();   //对两个排序进行归并排序；
     lit1.sort();
     lit.merge(lit1);
     //-----------将list里的数据倒序排列---------------
     lit.reverse();
     for(it=lit.begin();it!=lit.end();it++)
     {
         cout<<*it<<"  ";
     }
     cout<<endl;
     for(it1=lit1.begin();it1!=lit1.end();it1++)
     {
         cout<<*it1<<"  ";
     }
     cout<<endl;
     system("pause");
     return ;
 } 

运行结果：

再说下上面用到地List的两个函数：uniqie（）和splice（）；

1、uniqie（）：

　　在STL中unique函数是一个去重函数， unique的功能是去除相邻的重复元素(只保留一个),其实它并不真正把重复的元素删除，是把重复的元素移到后面去了，然后依然保存到了原数组中，然后 返回去重后最后一个元素的地址，因为unique去除的是相邻的重复元素，所以一般用之前都会要排一下序。　　

unique返回的迭代器指向超出无重复的元素范围末端的下一个位置。

注意：算法不直接修改容器的大小。如果需要添加或删除元素，则必须使用容器操作。

 #include <iostream>
 #include <cassert>
 #include <algorithm>
 #include <vector>
 #include <string>
 #include <iterator>
  using namespace std;

  int main()
 {
     //cout<<"Illustrating the generic unique algorithm."<<endl;
     const int N=;
     int array1[N]={,,,,,,,,,,};
     vector<int> vector1;
     for (int i=;i<N;++i)
         vector1.push_back(array1[i]);

     vector<int>::iterator new_end;
     new_end=unique(vector1.begin(),vector1.end());    //"删除"相邻的重复元素
     assert(vector1.size()==N);

     vector1.erase(new_end,vector1.end());  //删除（真正的删除）重复的元素
     copy(vector1.begin(),vector1.end(),ostream_iterator<int>(cout," "));
     cout<<endl;

     return ;
 }

结果：1 2 0 3 0 7 0 8

unique_copy（）

算法标准库定义了一个名为unique_copy的函数，其操作类似于unique。

唯一的区别在于：前者接受第三个迭代器实参，用于指定复制不重复元素的目标序列。

unique_copy根据字面意思就是去除重复元素再执行copy运算。

编写程序使用unique_copy将一个list对象中不重复的元素赋值到一个空的vector对象中。

 //使用unique_copy算法
 //将一个list对象中不重复的元素赋值到一个空的vector对象中
 #include<iostream>
 #include<list>
 #include<vector>
 #include<algorithm>
 using namespace std;

 int main()
 {
     int ia[] = { ,  ,  ,  ,  ,  , };
     list<int> ilst(ia , ia + );
     vector<int> ivec;

     //将list对象ilst中不重复的元素复制到空的vector对象ivec中
     //sort(ilst.begin() , ilst.end());  //不能用此种排序，会报错
     ilst.sort();  //在进行复制之前要先排序，切记
     unique_copy(ilst.begin() , ilst.end() , back_inserter(ivec));

     //输出vector容器
     cout<<"vector: "<<endl;
     for(vector<int>::iterator iter = ivec.begin() ; iter != ivec.end() ; ++iter)
         cout<<*iter<<" ";
     cout<<endl;

     return ;
 }

假如

list<int> ilst(ia , ia + 7);
改为：vector<int> ilst(ia , ia + 7);

则排序时可用：

sort(ilst.begin() , ilst.end());

这里要注意list和vector的排序用什么方法。

Effective STL》里这些话可能有用处：
item 31
　　
　　“我们总结一下你的排序选择：
　　 ● 如果你需要在vector、string、deque或数组上进行完全排序，你可以使用sort或stable_sort。
　　 ● 如果你有一个vector、string、deque或数组，你只需要排序前n个元素，应该用partial_sort。
　　 ● 如果你有一个vector、string、deque或数组，你需要鉴别出第n个元素或你需要鉴别出最前的n个元素，而不用知道它们的顺序，nth_element是你应该注意和调用的。
　　 ● 如果你需要把标准序列容器的元素或数组分隔为满足和不满足某个标准，你大概就要找partition或stable_partition。
　　 ● 如果你的数据是在list中，你可以直接使用partition和stable_partition，你可以使用list的sort来代替sort和stable_sort。如果你需要partial_sort或nth_element提供的效果，你就必须间接完成这个任务，但正如我在上面勾画的，会有很多选择。
　　
　　另外，你可以通过把数据放在标准关联容器中的方法以保持在任何时候东西都有序。你也可能会考虑标准非STL容器priority_queue，它也可以总是保持它的元素有序。

2、splice（）

list::splice实现list拼接的功能。将源list的内容部分或全部元素删除，拼插入到目的list。

函数有以下三种声明：

void splice ( iterator position, list<T,Allocator>& x );  //

void splice ( iterator position, list<T,Allocator>& x, iterator i );

void splice ( iterator position, list<T,Allocator>& x, iterator first, iterator last );

函数说明：在list间移动元素：

将x的元素移动到目的list的指定位置，高效的将他们插入到目的list并从x中删除。

目的list的大小会增加，增加的大小为插入元素的大小。x的大小相应的会减少同样的大小。

前两个函数不会涉及到元素的创建或销毁。第三个函数会。

指向被删除元素的迭代器会失效。

参考：https://blog.csdn.net/gogokongyin/article/details/51178378

　　https://www.cnblogs.com/heyonggang/archive/2013/08/07/3243477.html

　　https://blog.csdn.net/bichenggui/article/details/4674900