STL
STL 在广义上主要分为三类：
1. algorithm(算法)：完成特定的功能
2. container(容器)：用于存储数据
3. iterator(迭代器): 类似于指针，用于访问容器中的内容
STL - Algorithm(算法)
STL 中大部分的算法都在 <algorithm> 库中，用的时候只需要在头文件中包含进来即可
#include <algorithm>
* 接下来介绍几个在程序中常使用的算法：
STL - Algorithm(算法) - min, max(取最值)
* min(x, y)：取两者中的较小值
* max(x, y)：取两者中的最大值
- 它们调用起来十分简单，只要满足 x,y 是相同类型，并
且可以比较大小即可。
int a = 5, b = 4, c = min(a, b); // c = 4 double x = 1.5, y = 3.5, z = max(x, y); // z = 3.5
STL - Algorithm(算法) - swap(交换)
* swap(x, y)：交换两者的值
- 调用时只要满足 x,y 是相同类型即可。
int a = 5, b = 4; swap(a, b); // a = 4, b = 5 double x = -1.0, y = 2.5; swap(x, y); // x = 2.5, y = -1.0 // !swap(a, x) 无法调用：类型不相同
STL - Algorithm(算法) - sort(排序)
* sort(first, last)：对于在 [first, last) 中的元素进行排序
* sort(first, last, comp)：对于在 [first, last) 中的元素进行排序，其中 comp 为比较器
int a[10] = {5, 2, 1, 3, 4}; sort(a, a+5);// a = [1, 2, 3, 4, 5, ...] 普通排序 int cmp(int x, int y){return x > y;} // 比较器 sort(a, a+5, cmp);// a = [5, 4, 3, 2, 1, ...] 从大到小排序
int a[10] = {5, 2, 1, 3, 4}; sort(a, a+5);// a = [1, 2, 3, 4, 5, ...] 普通排序
* 几点需要注意的地方：排序的区间为[first, last)，左闭右开；
如果需要排序A[1..5]中的数，则需要调用sort(A+1, A+6)；
* 可以自己定义比较器，作为排序的准则：例如，我们需要按照个
位数来比较大小，则可以定义比较器为
int cmp(int x, int y){return x % 10 < y % 10;}
* 对于自己定义的结构体，可以定义自己的比较器来实现排序功能。
// 以 a 为第一关键字，b 为第二关键字进行排序 int cmp(Mystruct x, Mystruct y) {return x.a == y.a ? x.b < y.b : x.a < y.a;}
STL - Algorithm(算法) - lower_bound (查找)
* lower_bound(first, last, element)：给定 [first, last)
中的已经从小到大好排序的元素，找出最前的一个不比 element
要小的元素的位置
int a[10] = {5, 2, 1, 3, 4, 3, 2, 4}; sort(a, a+8); // a = [1, 2, 2, 3, 3, 4, 4, 5] 已从小到大排好序 int p2 = lower_bound(a, a+8, 2) - a; // p2 = 1 // a中最前的不比 2 小的元素是: a[1] = 2 int p4 = lower_bound(a, a+8, 4) - a; // p4 = 5 // a中最前的不比 4 小的元素是: a[5] = 4 int p0 = lower_bound(a, a+8, 0) - a; // p0 = 0 // a中最前的不比 0 小的元素是: a[0] = 1 int p6 = lower_bound(a, a+8, 6) - a; // p6 = 8 // a中没有不比 6 小的元素，所以返回最后的一个位置 a[8] // 注意:a[8] 中并没有值，是数组的最末端
STL - 容器 (Container)
* STL 中的容器被分配在不同的库中，用的时候只需要在头文件中
包含对应的库即可
#include <vector> // 向量：用于存储连续的元素，类似数组 #include <set> // 集合 #include <queue> // 队列 #include <stack> // 栈 #include <map> // 映射：相当于一个坐标无限大的数组 #include <priority_queue> // 优先队列：类似于堆 #include <list> // 列表：类似于链表
* 接下来介绍几个在程序中常使用的容器。
STL - 容器 (Container) - 向量 (vector)
* 向量 (vector)：用于存储连续的元素，类似数组；并且可以动态改变数组的大小(不必提前声明数组大小)
//vector声明 vector<int>a; vector<int>b(5, 0); int n; //vector访问 void vis() { for(int i=0; i<5; i++) b[i] = i; for(int i=0; i<5; i++) cout<<b[i]<<" "; return ; } //vector添加元素 void add() { cin>>n; for(int i=0; i<n; i++) a.push_back(i * i);//尾部插入数字 for(int i=0; i<n; i++) cout<<a[i]<<" "; return ; } //插入元素 a.insert(a.begin()+i,xx); //在第i+1个元素前面插入xx //删除元素 a.erase(a.begin()+i); //第i+1个元素被删除 //vector设定长度 vector<int>c; c.resize(5);//设置c的大小为5，下标 //vector长度（数组大小） int len = c.size(); //len = 5 在此时c[4] 是可以访问的 //vector清空 c.clear();//清空c数组 vector一旦清空，长度变为0，所以不可以访问c[4]
* 向量 (vector)还有更多的内置函数，这里就不再一一介绍；感
兴趣可以访问www.cplusplus.com自行查阅相关内容。
STL - 容器 (Container) - 二元组 (pair)
* 二元组 (pair)：用于存储二元组 (x,y)(并且 x,y 类型可以不相同)
#include <algorithm> // pair 声明 pair<int, int> a; // 声明一个二元组 a，用尖括号括起来 pair<int, int> b(3, 4); // 声明一个二元组 b， x=3, y=4 typedef pair<int, int> PI; // 使用类型定义 PI c(5, 6); // 声明一个二元组 c // pair 访问 int x = c.first, y = c.second; // x = 5, y = 6 PI d = c; // 相同类型的二元组可以直接赋值 c = PI(7, 8); // 重新赋值二元组 d = make_pair(9, 10); // 另一种赋值方式
* 二元组 (pair)的一个优点是可以直接比较大小；它会先比较第
一关键字(x)，再比较第二关键字(y)。
可以自己定义cmp
PI arr[10]; for(int i=0; i<5; i++) arr[i] = PI(5 - i, i * i); sort(arr, arr+5); for(int i=0; i<5; i++) cout << "First␣element:" << arr[i].first << "␣" << "Second␣element:" << arr[i].second << endl; 输出结果： First element:1 Second element:16 First element:2 Second element:9 First element:3 Second element:4 First element:4 Second element:1 First element:5 Second element:0
* 通过二元组 (pair)可以把不同类型的元素给有机整合起来：
三元组：
typedef pair<int, PI> PII; // 定义三元组 PII p = PII(2, PI(4, 8)); // 嵌套定义三元组 cout << p.first << "," << p.second.first << "," << p.second.second << endl; // 嵌套输出 typedef pair<string, int> People; // 定义字符串 -整数二元组 People pa("Edward", 16); People pb("Bob", 17); if(pa > pb) swap(pa, pb); // 比较大小 cout << pa.first << ":" << pa.second << endl; // 输出较小值
STL - 容器 (Container) - 集合 (set)
* 在集合 (set)中，可以像普通的集合一样，保存所有不同的数：
set<int> S; // 定义一个整型类型的 set for(int i=0; i<10; i++) S.insert(i*i); // 把 0-9 的平方数加入集合中 set<int>::iterator p; // iterator：迭代器，相当于一个指针 p = S.find(4); // 指针 -- 找到 4 所在位置 cout << *p << endl; // 输出这个位置的值 -- 4 ++p; // 指针后移 cout << *p << endl; // 输出后一个平方数的值 -- 9
输出结果：
4
9
* 在集合 (set)中，可以支持查找一个数的位置：
p = S.find(5); // 假如我们想要找一个集合中没有的数 cout << "Notice␣:␣(5␣is␣not␣a␣square␣number)␣" << *p << endl; cout << (p == S.end()) << endl; // 就会返回一个特殊的指针：S.end() 结尾的指针 // C++ 中的容器都是左闭右开的： // S.begin() 头指针 - 存放数据，S.end() 尾指针 - 不存放数据 输出结果： Notice : (5 is not a square number) 10 1
如果要找的数不在集合里，输出集合里所有数的个数
如果输出一个条件的话，如果满足条件输出1，不满足输出0
* 在集合 (set)中，还有另一种方式查看一个数是否在集合中：~.count --> 判断某个值是否在数组中，如果在数组中为真，否则为假
for(int i=0; i<10; i++) if(S.count(i)) cout << i << "␣is␣an␣element␣of␣S." << endl; else cout << i << "␣is␣not␣an␣element␣of␣S." << endl; // count(x)，如果 x 存在则返回 1，不存在则返回 0 输出结果： 0 is an element of S. 1 is an element of S. 2 is not an element of S. 3 is not an element of S. 4 is an element of S. 5 is not an element of S. 6 is not an element of S. 7 is not an element of S. 8 is not an element of S. 9 is an element of S.
* 在集合 (set)中，亦可以直接支持lower_bound 操作：~.delete() --> 删除某个数 ; ~.lower_bound() --> 寻找某个数
p = S.lower_bound(20); // 假如我们想要找一个集合中不小于 20 的数 cout << "The␣first␣element␣not␣lower␣than␣20:␣" << *p << endl; S.delete(p); // 删除一个数：使用指针的方式 p = S.lower_bound(20); // 再次寻找 cout << "The␣first␣element␣not␣lower␣than␣20:␣" << *p << endl; p = S.lower_bound(100); // 假如我们想要找一个集合中不小于 100 的数 cout << (p == S.end()) << endl; // 假如没有数比它大，则返回尾指针 输出结果： The first element not lower than 20: 25 The first element not lower than 20: 36 1
STL - 迭代器 (Iterator)
↓ 迭代器的运用：
vector<int>::iterator vi; // 定义迭代器，直接在后面加::iterator vector<int> V; // 定义容器 for(int i=1; i<10; i++) V.push_back(i * 3 - 2); // 新增值 for(vi = V.begin(); vi != V.end(); ++vi) cout << *vi << "␣"; cout << endl; // 按顺序输出容器中的值 // 特殊的迭代器：V.begin(), V.end()(左闭右开) // 迭代器可以自增：往后挪一位 // 不同容器的迭代器存在着区别 输出结果： 1 4 7 10 13 16 19 22 25
// STL 中每个容器都有对应的迭代器。 set<int> S; // 定义容器 set<int>::iterator p; // 定义迭代器 for(int i=0; i<10; i++) S.insert(i * i); // 插入平方数 p = S.begin(), ++p; S.erase(p); // 第一种删除方式（迭代器） ：删除第二个元素 S.erase(49); // 第二种删除方式（值删除） ：删除 49 cout << "The␣Sequence␣:␣"; for(p = S.begin(); p != S.end() ; ++p) cout << *p << "␣"; cout << endl; // 顺序输出 输出结果： The Sequence : 0 4 9 16 25 36 64 81
↑ 迭代器两种删除方式
