1、vector：
vector<int> v
vector<int> v(10)//定义大小为10的int型向量容器。
vector<int> v(10，3)//定义大小为10，每个元素为3。
v.push_back(2)//尾部添加元素2.
v.pop_back()//尾部删除一个元素.
v[0]=2
v[1]=3//下标访问。
vector<int>::iterator it//迭代器访问
for(it=v.begin()it!=v.end()it++)
{
cout<<*it<<" "
}
//元素插入，插入位置必须是迭代器位置
v.insert(v.begin()，8)//最前面插入
v.insert(v.begin()+2，8)
v.insert(v.end()，8)//末尾追加
//元素删除
v.erase(v.begin()+2)//删除第2+1个元素
v.erase(v.begin()+1，v.begin()+5)//删除迭代器第一到第五区间的所有元素
v.clear()//删除所有元素
reverse(v.begin()，v.end())//反向排列向量所有元素（可以反向排列某段迭代器区间元素）
sort(v.begin()，v.end())//sort排序（默认升序排列）
//设计排序比较函数
bool comp(const int& a，const int& b)
{
return a>b//降序排列
}
sort(v.begin()，v.end()，comp)
v.size()//返回向量大小，即元素个数
v.empty()//判空，空时返回1，不空时返回0。
2、stack：
//堆栈容器
stack<int> s
s.push(1)//入栈
s.pop()//出栈
s.top()//返回栈顶元素
s.size()//返回元素个数
s.empty()//判空
3、queue：
//队列容器
//只能从队尾插入元素，队首删除元素
queue<int> q
q.push(1)//入队
q.pop()//出队
q.front()//返回队首元素
q.back()//返回队尾元素
q.size()//返回元素个数
q.empty()//判空
4、priority_queue：
//优先队列容器
//只能从队尾插入元素，队首删除元素
//队列中最大的元素总是位于队首（默认从大到小排序，自己可以自定义比较函数来修改）
priority_queue<int> pq
pq.push(1)//入队
pq.pop()//出队
pq.top()//返回队首元素
pq.size()//返回元素个数
pq.empty()//判空
//自定义比较函数
元素为结构体：
struct info
{
string name
float score
bool operator < (const info &a) const
{
return score>a.score//从小到大（注意这次的符号）
}
}
元素非结构体：
struct mycomp
{
bool operator () (const int &a，const int &b) const
{
return a>b//从小到大（注意这次的符号）
}
}
priority_queue<int，vector<int>，mycomp> pq//显示说明其内部结构是vector.（注意：当有自定义比较函数时，必须显示说明其内部结构是vector！）
5、deque：
创建
deque<int> d
deque<int> d(10)//容量为10
deque<int> d(10，8.5)//10个并初始化为8.5
插入：
push_back()尾部插入，扩张队列
push_front()头部插入，不扩张队列，往后挤，把尾部的元素挤出去了
以上两个参数是一个元素对象
insert()中间某位置插入元素，不扩张队列，仍是挤出尾部的元素
参数为两个：迭代器位置+元素对象
eg：d.insert(d.begin()+1，88)//即插入到第二个位置，后面的往后顺延，最后一个丢失
遍历：
d[i]//数组方式
deque<int>::iterator it
for(it=d.begin()it!=d.end()it++)
{
cout<<*it<<" "
}//前向迭代器方式
deque<int>::reverse_iterator it
for(rit=d.rbegin()rit!=d.rend()rit++)
{
cout<<*rit<<" "
}//反向迭代器方式
删除：
首部：d.pop_front()
尾部：d.pop_back()
中间：d.erase(d.begin()+1)
清空：d.clear()
6、set：
#include <set>
#include <algorithm>
//不会重复插入相同键值的元素
//采用红黑树的平衡二叉检索树结构，中序遍历
set<int> s
s.insert(3)//默认从小到大
set<int>::iterator it
for(it=s.begin()it!=s.end()it++)
{
cout<<*it<<" "
}
//反向遍历
set<int>::reverse_iterator rit//反向迭代器
for(rit=s.rbegin()rit!=s.rend()rit++)
{
cout<<*rit<<" "
}
//元素删除，删除对象可以是某个迭代器位置上的元素、等于某键值的元素、一个区间上的元素
s.erase(s.begin()+1)
s.erase(6)
s.erase(s.begin()，s.begin()+4)
s.clear()
s.size()
s.find(6)//查找键值6，查到了则返回其迭代器位置，否则返回最后一个元素后面的位置，即end()
set<int>::iterator it
it=s.find(6)
if(it!=s.end())
cout<<*it<<endl
//自定义比较函数 默认从小到大存储
//非结构体元素
struct comp
{
bool operator () (const int& a，const int& b) const
{
return a>b//从大到小
}
}
set<int，comp> s//创建
set<int，comp>::iterator it
其他操作一样
//结构体元素
struct info
{
string name
float score
bool operator < (const info &a) const
{
return score>a.score//从大到小
}
}
set<info> s//创建
set<info>::iterator it
7、multiset：
#include <set>
#include <algorithm>
//允许重复的元素键值插入
//在插入，删除，查找方面与<set>有区别
multiset<string> ms
ms.insert("abc")
multiset<string>::iterator it
//erase()可以删除某个迭代器位置的元素，某段区间的元素，键值等于某个值的所有重复元素（并返回删除元素个数）。
ms.erase(蕋")
ms.clear()
//find()，如果查到，返回该元素第一次出现的迭代器位置，否则返回end()
it=ms.find(蕋")
8、map：
#include <map>
#include <algorithm>
//不会重复插入相同键值的元素
//采用红黑树的平衡二叉检索树结构，中序遍历
//比较函数只对键值进行比较
//和set使用大都相同
map<string，float> m
m["jack"]=98.5//插入元素
m.insert(pair<string，float>("lvhuan"，18.5))
map<string，float>::iterator it
for(it=m.begin()it!=m.end()it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl//输出键值与映照数据
}
//可以删除某个迭代器位置元素、等于某键值的元素、某迭代器区间的所有元素
m.erase(4)
m.clear()
//反向遍历
map<string，float>::reverse_iterator it
for(it=m.rbegin()it!=m.rend()it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl//反向输出键值与映照数据
}
//find()返回键值所处迭代器位置或end()位置
//自定义比较函数（默认从小到大）
非结构体元素
struct comp
{
bool operator () (const int &a，const int &b) const
{
return a>b//从大到小
}
}
map<int，char，comp> m
map<int，char，comp>::iterator it
结构体元素
struct info
{
string name
float score
bool operator < (const info &a) const
{
return score>a.score//从大到小
}
}
map<info，int> m//创建
map<info，int>::iterator it
for(it=m.begin()it!=m.end()it++)
{
cout<<(*it).second<<":"
cout<<((*it).first).name<<" "<<((*it).first).score<<endl
}
9、multimap：
#include <map>
#include <algorithm>
//允许重复插入相同键值的元素
multimap<string，float> m
m["jack"]=98.5//插入元素
m.insert(pair<string，float>("lvhuan"，18.5))
multimap<string，float>::iterator it
for(it=m.begin()it!=m.end()it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl//输出键值与映照数据
}
//erase()可以删除某个迭代器位置的元素，某段区间的元素，键值等于某个值的所有重复元素（并返回删除元素个数），还有清空clear()
//find()，如果查到，返回该元素第一次出现的迭代器位置，否则返回end()
it=m.find(蕋")
10、list：
//双向循环链表容器
//迭代器只能使用“++”或“--”，不能使用“+n”或“-n”。
创建：
list<int> l
list<int> l(10)//容量10
插入，都会自动扩张：
尾部：push_back()
首部：push_front()
中间：只能插到迭代器位置处：l.insert(it，20)//元素对象为20
遍历：
list<int>::iterator it
for(it=l.begin()it!=l.end()it++)
{
cout<<*it<<" "
}//前向迭代器方式
list<int>::reverse_iterator it
for(rit=l.rbegin()rit!=l.rend()rit++)
{
cout<<*rit<<" "
}//反向迭代器方式
删除：remove()删除一个元素值，值相同的元素都会被删除。
l.remove(1)//删除值为1的所有元素
l.pop_front()//删除首部元素
l.pop_back()//删除链表尾部元素
list<int>::iterator it
for(it=l.begin()it!=l.end()it++)
{
cout<<*it<<" "
}
it=l.begin()
it++
it++
l.erase(it)//删除迭代器位置元素
l.clear()//清空
查找：find()，找到则返回迭代器位置，否则返回end().
eg:it=find(l.begin()，l.end()，5)//查找这个区间上的值为5的元素的位置
升序排序：
l.sort()
删除连续重复元素，只保留一个：
l.unique()//注意是删除连续重复，不是单单重复
11、bitset：
//bit位元素的序列容器，每个元素只占一个bit位，取值0或1.
/*
bitset类
方法列表：
b.any() b中是否存在置为1的二进制位
b.none() b中不存在置为1的二进制位吗
b.count() b中置为1的二进制位的个数
b.size() b中二进制位的个数
b[pos] 访问b中在pos处的二进制位
b.test(pos) b中在pos处的二进制位是否为1
b.set() 把b中所有二进制位都置为1
b.set(pos) 把b中在pos处的二进制位置为1
b.reset() 把b中所有二进制位都置为0
b.reset(pos) 把pos处的二进制位置为0
b.flip() 把b中所有二进制位取反
b.flip(pos) 把pos处的二进制位取反
b.to_ulong() 用b中同样的二进制位返回一个unsigned long值
os<<b 把b中的位集输出到os流
*/
//创建
bitset<100000> b//创建时必须指定容器大小，且不能再修改大小。默认初始值为0.
//元素赋值
b[6]=1//下标法，最低位为第0位
b.set()//全部置1
b.set(6)//将指定位置1
b.reset()//全部置0
b.reset(6)//指定位置0
//输出元素
cout<<b[i]//下标法输出，可以借用b.size()来控制个大规模输出
cout<<b//注意输出的可是二进制形式哦（01串）
