c11容器常用方法？
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("123");
ms.clear();
//find()，如果查到，返回該元素第一次出現的迭代器位置，否則返回end()
it=ms.find("123");
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("123");
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串）
