零 pair ：模板类型，相当于包含两个变量的struct。
0. 头文件<iostream> 注意声明using namespace std;
1. 创建 //pair<>中的变量类型可以不相同，double/string/vector等等均可，pair<int, pair<int,string> > 。
① pair <int,int> p;
② pair <int,int> p1(1,2);
2. 赋值
① p.first=1; p.second=2;
② p=make_pair(1,2);
③ p=p1;
一 map<key, value> / unordered_map ：从键（key）到值（value）的映射。
-1.map & unordered_map 的异同：map内部由红黑树实现，有序并按照key升序存储，查找、插入、删除的复杂度为 O(logn) ; unordered_map内部由哈希表实现，无序，忽略冲突的情况下，查询、插入、删除复杂度为 O(1)。相同点是，不论内部由什么实现，从外部来看，两个容器都只是对pair进行管理，并不是真的哈希表或者红黑树；两种容器都具有key的唯一性。如果注重顺序性，则选择map；如果需要多次查找，则选择unordered_map。
0.头文件<map> <unordered_map>
1.创建 map<int,string> mapStudent; // unordered_map<int,string> mapStudent;
2.大小 int nSize=mapStudent.size();
3.清空与判空 map.clear(); map.empty(); //返回ture表示空
4.遍历
①前向迭代器 map<int,string>::iterator iter;
for( iter=mapStudent.begin();iter!=mapStudent.end(); iter++){iter->first=1; iter->second="student1";}
②反向迭代器 map<int, string>::reverse_iterator iter;
③数组式访问（不建议） int nSize=mapStudent.size();
for(int n=1; n<nSize; n++ ){...}
1 //本来我以为map就用最简单的数组式遍历就行，结果发现了一个魔性的问题
2
3 #include <iostream>
4 #include <map>
5 #include <cstring>
6 using namespace std;
7
8 int main() {
9
10 map<int,string> m1;
11 m1[1]="mfirst";
12 m1[2]="msecond";
13 m1[4]="mthird";
14
15 for(int n=0;n<m1.size();n++){
16 cout<<m1.size()<<" "<<m1[n]<<endl;
17 }
18 return 0;
19 }
20
21 上面这段代码实际输出结果为：
22 3
23 4 mfirst
24 4 msecond
25 4
26 5 mthird
27 ——————————
28 出现这个问题可能跟[]操作重载的定义有关系。很明显可以看到m.size()的值随着map的遍历增加了。从数组的角度上来说可以把map看成一个数组。
29 开始 map[0].first=0; map[0].second="";
30 map[1].first=1; map[1].second="mfirst";
31 map[2].first=2; map[2].second="msecond";
32 map[3].first=4; map[3].second="mthird";
33 当开始遍历的时候，map.size() 就已经+1；当遍历到 n=3的时候，原先的map[3]变成map[4],重新创建了一个新的map[3]，所以变成
34 map[0].first=0; map[0].second="";
35 map[1].first=1; map[1].second="mfirst";
36 map[2].first=2; map[2].second="msecond";
37 map[3].first=2; map[2].second="";
38 map[4].first=4; map[3].second="mthird";
39 总之很魔性，不建议使用这个方式进行遍历。
备注
5.查找
①count函数判定关键字是否出现，但无法定位数据出现的位置，返回值为 0/1。
②find函数定位关键词出现的位置，返回数据所在位置的迭代器，若数据不存在，返回map.end()的值。
map<int , string>::iterator iter;
iter=mapStudent.find(1);
6.插入
注：键值相同的元素插入不会覆盖之前的数据，相当于没有插入！
① mapStudent.insert(pair<int, string>(1, “student_one”));
② mapStudent.insert(map<int, string>::value_type (1, “student_one”));
③ mapStudent[1] = “student_one”;
7.删除
①迭代器删除 map<int , string>::iterator iter;
iter=mapStudent.find(1);
mapStudent.erase(iter);
②关键字删除 int n=mapStudent.erase(1);//删除了返回1，否则返回0
③mapStudent.earse(mapStudent.begin(),mapStudent.end());
二 set 集合
0.头文件<set> set内部与map一样，自建一棵红黑树，这颗树具有自动排序功能，所以set所有元素升序存储。
1.创建 set< pair<int,string>> m;
2.大小 int mSize=m.size();
3.清空与判空 m.clear(); m.empty(); //返回ture表示空
4.遍历 迭代器 set< pair<int,int> >::iterator iter; for (iter=m.start(); iter!=m.end(); iter++) {...}
5.查找 count() find()
6.插入 insert()
7.删除 erase()
8.定位 lower_bound() upper_bound()
三 vector 向量
0.头文件 <vector>
1.创建 vector<int> a;
2.大小 a.size();
3.清空与判空 m.clear(); m.empty();
4.遍历 迭代器
5.查找 count() find()
6.插入 push_back(value)//在元素末尾加入value； insert(iterator, value);在iterator前面加入value；
7.删除 erase(iterator);
8.首末元素 begin();//指向起始元素 end();//指向最后一个元素的下一个位置；
9.排序 sort(a.begin(),a.end());
四 queue 队列
0.头文件<queue>
1.创建 queue< pair<int,string>> q;
2.大小 int qSize=m.size();
3.判空 m.empty(); //返回ture表示空，没有清空
4.返回队首队尾 front() back()
5.插入弹出 push() pop()
五 stack 栈
0.头文件<stack>
1.创建 stack<char> q;
2.大小 int qSize=m.size();
3.判空 m.empty(); //返回ture表示空，没有清空
4.返回栈顶 top()
5.插入弹出 push() pop()
