一、Stack（栈）
- 这个没啥好说的，就是后进先出的一个容器。
- 基本操作有：
stack<int>q;
q.push(); //入栈
q.pop(); //出栈
q.top(); //返回栈顶成员
q.size(); //返回栈成员个数
q.empty(); //判断是否为空栈
二、Queue（队列）
- 同上，先进先出的容器
- 基本操作有：
queue<int>q;
q.push(); //入队列
q.pop(); //出队列
q.front(); //返回最上面（最后进入）的成员
q.size(); //返回队列成员个数
q.empty(); //判断是否为空队列
三、Priority_Queue（优先队列）
- priority_queue的模板生命是带有三个参数的：priority_queue<type,container,function>
- 和队列差不多，不过每个成员都有一个优先级参数，队列按照优先级进行排序
- 默认container是vector，默认function比较模式为operator <（即栈顶为最大值）。
- 基本操作有：
priority_queue<int,vector<int>,greater<int> >q;
q.push(); //入优先队列
q.top(); //返回优先队列头成员
q.pop(); //出优先队列
q.size(); //返回优先队列成员个数
q.empty(); //判断是否为空优先队列
- 内置的排序方式有greater<>，和less<>，不填此参数默认为greater<>。当然也可以自己构造优先级函数
- 例如对结构体重载运算符：
struct node{
int x,y;
//重载运算符，按x的值排优先级
friend operator < (node a,node b){
return a.x < b.x;
}
};
- 也可以将重载操作写在外面，优先队列中调用cmp函数
struct node{
int x,y;
};
struct cmp{
//重载运算符，按x的值排优先级
bool operator() (node a,node b){
return a.x < b.x;
}
};
priority_queue<node,vector<node>,cmp >q;
四、Deque（双向队列）
- 一听就知道和Queue差不多 ，特殊的是Deque可是扩充内存。我们知道连续内存的容器不能随意扩充，所以Deque也不是真正意义上的扩充内存。
- Deque是由一段一段构成的，当走到尾端时自动跳到下一段，（支持迭代器++操作）。每次扩充，申请一个段，实现了内存连续的假象。
- 基本操作有：
int num[] = {,,,,,};
deque<int>q; //创建一个空双向队列
deque<int>p(); //创建一个具有5个成员的双向队列
deque<int>s(,); //创建一个具有5个成员且初始值为1的双向队列
deque<int>s2(s); //创建一个双向队列s2，并拷贝s中所有成员
deque<int>n(num,num+); //创建一个双向队列n，并拷贝num至num+5中元素入队
q.push_front(a); //头部入队
q.pop_back(b); //尾部入队
q.insert(iter,x); //在iter位置插入x，iter为迭代器
q.pop_front(); //头部出队
q.pop_back(); //尾部出队
q.front(); //返回头成员
q.back(); //返回尾元素
q.size(); //返回双向队列成员个数
q.max_size(); //返回系统支持成员最大个数
q.empty(); //判断双向队列是否为空
q.at(i); //返回第i个元素
q.begin(); //返回头部迭代器
q.end(); //返回尾部迭代器
q.rbegin(); //返回尾部反向迭代器
q.rend(); //返回头部反向迭代器
q.erase(iter); //删除iter元素，iter为迭代器
q.clear(); //情况双向队列
q.swap(p); //交换q和p中的所有元素
- Deque采用分块线型结构存储数据，两个迭代器分别指向首尾元素，而且拥有具有高效的push_back(),push_front()函数。
- 正因如此，所以Deque不易实现capacity和reverse函数。
- Deque的缺点：频繁的插入删除时候，Deque并不适合。
五、Vector（动态数组）
- 顾名思义，不定长数组。
- uhmmm没啥好说的
- 基本操作有：
vector<int>q; //创建空Vector
vector<int>p(); //创建拥有5个成员的Vector
vector<int>s(,); //创建拥有5个成员，且初始值为1的Vector
vector<int>s2(s); //创建s2，并拷贝s元素给s2
vector<int>s3(s.begin(),s.end()); //创建s3，拷贝s.begin()至s.end()中元素给s3 q.push_back(x); //尾部加入元素
q.insert(iter,x); //在iter位置插入x，传回新数据位置
q.insert(iter,n,x); //在iter位置插入n个x，无返回值
q.insert(iter,l,r); //在iter位置插入[l,r)区间内的数据，无返回值
q.pop_back(); //删除最后一个元素
q.front(); //返回第一个数据
q.back(); //返回最后一个数据 q.size(); //返回容器内成员个数
q.resize(x); //重新指定容器大小
q.empty(); //判断Vector是否为空
q.capacity(); //返回Vector可用空间的大小
q.reserve(); //重新指定空间大小，小于当前capacity时保持为原本的capacity值
q.swap(p); //交换p，q容器内元素
q.assign(iter1,iter2); //将区间[iter1，iter2)内元素赋值给vector，并清空vector容器之前的内容。
q.assign(n,x); //将n个x赋值到vector中，并清空vector容器之前的内容。 q.at(i); //返回第i个元素
q.begin(); //返回头位置迭代器
q.end(); //返回尾位置迭代器
q.rbegin(); //返回尾部反向迭代器
q.rend(); //返回头部反向迭代器 q.clear(); //情况Vector
q.erase(); //删除iter位置元素
q.erase(iter1,iter2); //删除[iter1，iter2)区间内的元素
- 此外，vector还可以用数组的方式引用，因为以及内置重载了[]，例如q[0]等同于q.at(1)。
六、List（链表）
- 链表其实用的不多
- 自己也没怎么用过 =7= 直接放代码操作了
- 基本操作：
list<int>q; //创建空List
list<int>p(); //创建拥有5个成员的List
list<int>s(,); //创建拥有5个成员，且初始值为1的List
list<int>s2(s); //创建s2，并拷贝s元素给s2
list<int>s3(s.begin(),s.end()); //创建s3，拷贝s.begin()至s.end()中元素给s3 q.back() //返回最后一个元素
q.begin() //返回指向第一个元素的迭代器
q.clear() //删除所有元素
q.empty() //如果list是空的则返回true
q.end() //返回末尾的迭代器
q.erase() //删除一个元素 q.front() //返回第一个元素
q.get_allocator() //返回list的配置器
q.insert() //插入一个元素到list中
q.max_size() //返回list能容纳的最大元素数量
q.merge() //合并两个list
q.pop_back() //删除最后一个元素
q.pop_front() //删除第一个元素
q.push_front() //在list的头部添加一个元素 q.rbegin() //返回指向第一个元素的逆向迭代器
q.remove() //从list删除元素
q.remove_if() //按指定条件删除元素
q.rend() //指向list末尾的逆向迭代器
q.resize() //改变list的大小
q.reverse() //把list的元素倒转
q.size() //返回list中的元素个数
q.sort() //给list排序
q.splice() //合并两个list
q.swap() //交换两个list
q.unique() //删除list中重复的元素
七、Pair（对）
- 就是合成两个数据，这个用结构体模拟也行，但是直接使用Pair会方便很多
- 基本操作如下：
pair<int,int>q; //创建一个空对
pair<int,int>p(,);//创建一个对p，并分别赋值2，3
pair<int,int>s(p); //创建一个对s，拷贝p给s //赋值利用make_pair函数
q = make_pair(,);
//访问pair内元素操作
q.first; //返回成员第一个数据
q.second; //返回成员第二个数据
八、Set（集合）
- 首先Set遵循数学集合三特性，无重复、无序性、确定性。我就不解释了。
- Set中内置红黑树进行排序，所以插入删除效率很高。
- 常用操作如下：
int a[] = {,,,,};
set<int>q;
set<int>p;
q.insert(x); //集合中插入元素
q.insert(a,a+); //插入数组a至a+5的元素
q.find(x); //返回x值位置的迭代器，找不到返回q.end()
q.erase(iter); //删除集合中的元素
q.size(); //返回当前set容器中的元素个数
q.count(); //返回某个值元素的个数(根据set的特性，就是判断这个元素在不在，返回0或1)
q.begin(); //返回头位置迭代器
q.end(); //返回尾位置迭代器
q.rbegin(); //返回尾部反向迭代器
q.rend(); //返回头部反向迭代器
q.clear(); //删除set容器中的所有的元素
q.empty(); //判断set容器是否为空
q.lower_bound(); //返回指向大于（或等于）某值的第一个元素的迭代器
q.upper_bound(); //返回大于某个值元素的迭代器
- 当然，你也可以自定义Set内部的排序操作，例如：
struct cmp{
bool operator() (const node &a,const node &b){
return a.x < b.x;
}
};
set<node,cmp>q;
九、Map
- 不知道该翻译成啥，干脆不翻译了 =7=
- map是一种关联容器，例如map<int,int>，第一个元素可以称为关键字，类似数组的下标，不会重复出现，而第二个元素为关键字的值，类似数组中存的元素，可以重复。
- map不能直接修改关键字，只能通过修改关键字的值间接修改关键字。
- 和Set一样，map也是内置红黑树对关键字进行排序。能够实现快速查找和删除功能。
- 基本操作：
map<int,int>q;
q.insert(pair<int,int>(,)); //通过pair进行插入操作
q.insert(map<int,int>::value_type (,));//通过value_type进行插入
q[] = ; //用数组方式进行插入
/*三者不同的是，当map存在这个关键字时
*数组方式会覆盖关键字的值，而insert操作无法插入。
*/
q.size(); //返回容器内元素个数
q.empty(); //判断容器是否为空
q.begin(); //返回头位置迭代器
q.end(); //返回尾位置迭代器
q.rbegin(); //返回尾部反向迭代器
q.rend(); //返回头部反向迭代器
q.find(key); //查找并返回关键字key的位置
q.count(key); //查询是否有关键字key（有则返回1，否则0）
q.lower_bound();//返回键值>=给定元素的第一个位置
q.upper_bound();//返回键值>给定元素的第一个位置
q.erase(iter); //删除迭代器iter的元素
q.erase(iter1,iter2);//删除[iter1,iter2)区间内的元素
q.erase(key); //删除关键字为key的元素
q.clear(); //清空容器
q.swap(p); //交换两个map
q.key_comp(); //返回比较元素key的函数
q.max_size(); //返回可以容纳的最大元素个数
q.value_comp(); //返回比较元素value的函数
q.equal_range();//返回特殊条目的迭代器对
- 当然你可以自己写内部排序函数
- 例如结构体中重载<号，或者编写仿函数，例如：
class sort{
public:
bool operator() (node const &a,node const &b) const{
return a.x < b.x;
}
};
十、Multiset（多重集合）
- 和Set不同的地方是Multiset允许一个值出现多次；
- 操作和set相同。但是因为值能重复出现，所有某些函数的返回值将会改变，例如：
- multiset::count(key)返回值可能大于1；（多个关键值存在）
- multiset::erase(key)会将对应的key全部删掉。
- 对于set总是有set::equal_range(key)的返回值总有++iter1 = iter2.但multiset不一定（元素相同）
十一、Multimap
- 同上，和map类似，可以存在相同的关键字。
本来想讲BitSet，但是觉得bitset比较特殊，到时候专门详细讲吧。
其实所有容器都挺简单的，根据特性基本都能想出操作。熟悉了这些容器之后，对做题和学习很有帮助的。
记住操作没啥用，得不断的练习使用这些容器 ，才能熟练操作。
emmmm都说的很简陋，本来想讲每个容器的具体实现一起构造方式。后来一想，篇幅太长了，还容易误导别人觉得容器很复杂。这些都算是学个表面吧，最重要的还是不断敲敲敲，熟悉各种用法。
大致就这样吧 =7=
后续：Stack，Queue，Pair并不是C++的标准容器，但是我觉得性质差不多，就一起讲了，但是防止误导初学者，这里还是提一下。