队列

STL?中提供的三种常用队列：queue,deque,priority_queue? ? ? ? ??

?queue（普通队列）

queue<int> q; //声明: queue<数据类型> 变量名

q.pop()    //将队首出队（队列为空时会RE）
q.push(x)  //把元素 x 入队
q.front()  //得到队首
q.size()   //返回队列大小（元素个数）
q.empty()  //判断队列是否为空，空返回true，否则返回false

? ? 2.? deque（双端队列）

deque<int> d;    //声明: deque<数据类型> 变量名

q.pop_front()    //将队首出队（队列为空时会RE）
q.pop_back()     //将队尾出队（队列为空时会RE）
q.push_front(x)  //将元素x从队首入队
q.push_back(x)   //将元素x从队首入队
q.front()        //得到队首
q.back()         //得到队尾
q.size()         //返回队列大小（元素个数）
q.empty()        //判断队列是否为空，空返回true，否则返回false

? ?3.? priority_queue(优先队列-堆)? 注意默认的为大根堆，小根堆可以取负数实现

priority_queue<int> d;   //声明: priority_queue<数据类型> 变量名

q.pop()                  //将堆顶出堆（堆为空时会RE）
q.push_front(x)          //将元素x入堆           
q.top()                  //得到堆顶
q.size()                 //返回堆大小（元素个数）
q.empty()                //判断堆是否为空，空返回true，否则返回false

?二分查找

? ? ?STL 中同样提供了二分查找的函数

binary_search(起始地址，结束地址，查找元素);? 查找元素是否在数组中，为bool类型
lower_bound(起始地址，结束地址，查找元素);? 返回数组中第一个大于等于该元素的地址
upper_bound(起始地址，结束地址，查找元素);? 返回数组中第一个大于该元素的地址

?set

? ? ? set 是STL 中封装的一个集合，在log的时间内实现对元素的查找排序等，效率较高

set<int> s;            //声明：set<数据类型> 变量名
set<int>::iterator it; //set的迭代器

s.insert(x)  //在set中插入元素x
s.erase(x)   //若set中存在元素x，删除x
s.begin()    //返回第一个元素的地址
s.rbegin()   //返回最后一个元素的地址
s.end()      //返回set中的最后一个地址(没有真实值)
s.rend()     //返回第一个元素的地址(同s.begin())
s.size()     //返回set的大小
s.count(x)   //统计set中x的数量
s.clear()    //清空set
s.find(x)    //在set中查找第一个x的位置，返回地址，查找不到就返回s.end()
s.empty()    //判断set是否为空，空返回true，否则返回false
s.max_size() //返回set中最大能存元素的数目 
s.lower_bound(x) //在set中查找第一个大于等于x的元素，查找不到返回s.end()

? ?set会自动把元素去重，而multiset不会

map

? ??map是STL 提供的一个一对一映射的函数，在数组内自建一棵红黑树，可以用普通数组的方式? ? ? ? 访问（如mp[1]=1），类似哈希表等。

map<string,int> m; //声明：map<原来的类型，要映射的类型> 变量名
map<int,string>::iterator it;  //迭代器 

m.insert(pair<string,int>("qwq",1))  //用insert建立映射关系
m["qwq"]=1;                          //用数组的方式建立映射关系
m.size()                             //返回map的大小
for (it=m.begin();it!=m.end();it++)  //迭代器遍历map中的元素
for (int i=1;i<=m.size();i++)        //数组遍历map中的元素
m.erase(x)                           //删除关键字为x的元素
m.erase(it)                          //删除迭代器指向的位置

其他的操作与 STL-set 类似,详情可以看上面

vector

? ? ?STL? 中的一个向量

? ? 值得注意的是，vector 用数组访问时，只能访问以及赋值的元素

vector<int> v;            //声明：vector<数据类型> 变量名
vector<int>::iterator it  //迭代器

v.push_back(x) //在vector中插入元素x
v.begin()      //返回第一个元素的地址
v.end()        //返回vector中的最后一个地址(没有真实值)
v.size()       //返回vector的大小
v.count(x)     //统计vector中x的数量
v.find(x)      //在vector中查找第一个x的位置，返回地址，查找不到就返回v.end()

sort(v.begin(),v.end());                //对vector中的元素进行排序
reverse(v.begin(),v.end());             //翻转vector中的元素
copy(v1.begin(),v1.end(),v2.begin()+1); //把[v1.begin(),v1.end())的元素复制到v2中 
                                         （从v2.begin()+1开始，并且覆盖已有的元素）
find(v.begin(),v.end(),x);              //在[v1.begin(),v1.end())查找元素x

?list

? ? list 是STL中的一个链表结构

list<int> l();          //声明一个空链表l
list<int> l(n);         //声明一个大小为n的链表l
list<int> l(n,val);     //声明一个大小为n,元素全为val的链表l
list<int> l(l,r);       //声明一个列表l,其元素的初始值来源于由区间所指定的序列中的元素

基础操作与deque类似(l.front(),l.back(),l.pop_front(),l.push_front()等)

l.reverse(l.front(),l.back()) //把list进行翻转
l1.merge(l2,greater<int>());  //合并后升序排列(默认就是升序)

bitset?

? ? bitset是STL 提供的一个类似多位二进制数的容器

bitset<N> b;  //声明：bitset<大小> 变量名称

可以使用数组访问，但b[0]访问的是末尾元素，而不是首位（可以同个位理解）
b[x]=y          //对第x位赋值y
b.any()         //判断bitset是否存在值为1的二进制位
b.none()    	//判断bitset是否不存在值为1的二进制位
b.size()	    //返回bitset位长，也即是非模板参数值
b.count()	    //统计bitset值为1的个数
b.set()         //全部位 置1
b.reset()       //全部位 置0
b.set(pos)      //对pos位置1
b.reset(pos)    //对pos位置0
~b/b.flip()     //对bitset每位按位取反
b.flip(pos)     //把bitset的pos位取反

bitset 可以用 unsigned long long 与 string 的方式输出