一.vector-向量
1.定义：向量类型可以容纳许多类型的数据，被称为容器——可以当数组使用，可以随时增加或减少元素，内存连续，顺序表。
2.头文件: #include<vector>
3.常见用法：
vector<int> d(n); 定义一个存放int类型的容量为n的容器
vector<int> d(n,0); 定义一个存放int类型的容量为n的容器,并初始化每个元素为0
vector<int> d(b); 定义一个数组d，把b内所有元素拷贝至d中
vector<vector<<int>> d(n,vector<int>(m)) 定义二维数组
d.push_back(x); x存入数组末尾（自动扩充内存）
d.insert(d.begin()+y,x); 在y处插入x
d.assign(d.begin()+c,b.begin(),b.begin()+x) ;将b的前x个元素插入d的c位置
d.erase(i); 删除第i个元素
d.erase(d.begin(),d.begin()+x); 删除前x个元素
d.size(); 返回d内元素数目
d.front(); 返回d的最后一个元素
d.back(); 返回d的第一个元素
d.empty(); 返回d是否为空
d.resize(c，0); 将d中元素数目控制在c个，多删，少补用0补可以缺省，用随机数补
d.pop_back(); 删除d的最后一个元素
d.clear(); 将d清空
读取方式：for(int i=0;i<a.size();i++）cout<<a[i]<<" ";//下标方式获取
for(vector<int>::iterator it=a.beign();it!=a.end();it++) cout<<*it<<" ";//迭代器获取
4.常用算法:
#include<algorithm>
sort(a.beigin(),a.end()); 将a内元素从小到大排序
sort(a.beign(),a.end(),cmd); 将a内元素按照cmd函数所限制的规则排序
reverse(a.beigin(),a.end()); 将a内元素倒置 1 7 3 9 -》9 3 71
find(a.begin(),a.end(),c); 寻找c元素在a内的位置
copy(a.beign(),a.end(),b.beigin()+x); 将a内所有元素复制到b内，存储位置从x开始
二. list-双向链表
1.定义：双向链表，元素存储不连续，本身提供两个指针，用来指向第一个元素和最末尾的元素。
2.头文件: #include<list>
3.常用方法：
list<int> l(n); //定义一个可存放n个int类型元素的链表
list<int> l=l1;/list<int> l(l1); //新建一个链表l作为l1的拷贝
list<int> l(n,elem); //定义链表并用n个elem元素初始化;
l.assign(n,elem); //复制n个elem元素给l
l.assign(l1); //将l1赋值给l
l.assign(s,e); //将区间[s,e)内的元素复制给l
l.front(); //访问链首元素
l.back(); //访问链尾元素
l.push_back(x); //将x插入链尾
l.push_front(x); //将x插入链首
l.pop_back(); //删除链尾元素
l.pop_front(); //删除链首元素
l.insert(i,elem); // i位置前插入elem元素
l.insert(i,n,elem); //i位置前插入n个elem元素
l.insert(i,s,e); //i位置前插入从[i,e）之间的元素
l.clear(); //清空l
l.earse(i); //删除第i个元素
l.earse(s,e); //删除[s,e)之间的元素
l.resize(num); //将l内元素个数变为num个
l.remove(val); //将值为val的元素移除
l.unique(); //删除相邻重复元素，只保留一个
l.sort()； //升序排列
l.sort(op); //按照规则排序
l.merge(l1,op); //将l1排好序的元素合并至l内，并排序
l.reverse(); //l反转
4.与vector的区别：
（1）内存连续性：vector顺序表，内存连续，元素被顺序存储；list双向链表，内存不一定连续， 元素被随机存储；
（2）内存扩展：vector在扩充内存时，新申请一块足够大的内容，然后将所有元素复制到新内 存，list不需要考虑内存连续性，新增开销小
（3）访问元素：list只能通过指针访问元素，随机访问元素开销大，而vector可以通过索引随机元 素，开销小
（4）插入删除：vector插入或删除元素时，需要复制该位置右边所有元素，花销大，而list只需要 指针的移动。
总之,高效随机存取，不考虑插入、删除效率，用vector；不考虑随机存取，大量插入删除，用list。
三. deque-双端队列
1.定义：首尾皆可插入和删除的队列，也可以看作双端数组
2.头文件：#include<deque>
3.常见用法：
deque<int> dp; //定义存放int类型的双端队列
deque<int> dp(n,elem); //初始化dp内存入n个elem
deque<int> dp(b); //将b拷贝到dp内
dp.assign(a.begin(),a.end()); //将a拷贝到dp内
dp.push_back(x); //将x存入队尾
dp.front_back(x); //将x存入队头
dp.at(i); //返回索引为i的元素
dp.front(); //返回队首元素
dp.back(); //返回队尾元素
dp.size(); //返回队内元素个数
dp.empty(); //返回队列是否为空
dp.pop_back(); //删除队尾元素
dp.front_back(); //删除队首元素
dp.resize(n); //将队列长度变为n
dp.insert(i,elem); //在队列i位置前插入elem元素
dp.insert(i,n,elem); //在队列i位置前插入n个elem元素
dp.insert(i,s,e); //在队列i位置前插入从[i,e）之间的元素
dp.clear(); //清空dp
dp.earse(i); //删除第i个元素
dp.earse(s,e); //删除[s,e)之间的元素
四.queue-队列
1.定义：队列，一种先进先出，后进后出的数据结构
2.头文件：#include<queue>
3.常见用法：
queue<int> q; //定义队列
q.empty(); //返回队列是否为空
q.front(); //返回队列中的第一个元素
q.back(); //返回队列中的最后一个元素
q.push(x); //将x放入队尾
q.pop(); //删除队列中的第一个元素
q.size(); //返回队列内元素的数目
4.用途：广度优先遍历
五. priority_queue-优先队
1.定义：使用堆实现的默认最优元素至于队首的队列，与队列不同点在于赋予元素优先级，优先级高的排在队列前面，先出队。
2.头文件：#include<queue>
3.常见用法：
priority_queue<Type,Container,Functional> 定义，其中Type为数据类型，Container为容器可以为vector,deque,但是不能是list,Functional是比较方式
priority_queue<int,vector<int>,geater<int>> q; //定义升序队列
priority_queue<int,vector<int>,less<int>> q; //定义降序队列
priority_queue<pair<int,int>> q; //定义pair类型的队列
q.top(); //返回队头元素
q.pop(); //弹出队头元素
q.empty(); //返回队列是否为空
q.size(); //返回元素个数
q.push(x); //将x元素入队并排序
六.stack-栈
1.定义：栈，一种先入后出，后入先出的数据结构
2.头文件：#include<stack>
3.常见用法：
stack<int> s; 定义栈
s.empty(); 返回栈是否为空
s.top(); 返回栈顶元素
s.pop(); 弹出栈顶元素
s.push(i); 将元素i入栈
s.size(); 返回栈内元素个数
4.用途：用来模拟实现一些递归，防止程序对栈内存的限制而导致程序错误。
