STL常用容器-C++
1. String 容器
1.1 string 基本概念
本质：
- string 是 C++ 风格的字符串，而 string 本质上是一个类
string 和 char* 区别：
- char* 是一个指针
- string 是一个类，类内部封装了 char*，管理这个字符串，是一个 char* 型的容器
特点：
- string 类内部封装了很多成员方法。
例如：查找 find，拷贝 copy，删除 delete，替换 replace，插入 insert - string 管理 char* 所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责。
1.2 string 构造函数（初始化操作）
构造函数原型：
string();//创建一个空字符串 例如：string str;
string(const char* s);//使用字符串 s 初始化string(const string& str);//使用一个 string 对象初始化另一个 string 对象string(int n, char c);//使用 n 个字符 c 初始化
#include 总结：string 的多种构造方式没有可比性，灵活使用即可。
1.3 string 赋值操作
功能描述：
- 给 string 字符串进行赋值
赋值的函数原型：
string& operator=(const char* s);//char* 类型字符串赋值给当前的字符串string& operator=(const string* s);//把字符串 s 赋值给当前的字符串string& operator=(char c);//字符赋值给当前的字符串string& assign(const char* s);//把char* 类型字符串赋值给当前的字符串string& assign(const char* s, int n);//把char* 类型字符串的前 n 个字符赋给当前的字符串string& assign(const string* s);//把字符串 s 赋给当前的字符串string& assign(int n, char c);//把 n 个字符赋给当前的字符串
#include 总结：string 的赋值方式很多，operator=这种方式比较常用。
1.4 string 字符串拼接
功能描述：
- 实现在字符串末尾拼接字符串
函数原型：
string& operator+=(const char* str);//重载 += 操作符string& operator+=(const char c);//重载 += 操作符string& operator+=(const string& str);//重载 += 操作符string& append(const char* s);//把char* 类型字符串连接到当前字符串结尾string& append(const char* s, int n);//把char* 类型字符串的前 n 个字符连接到当前的字符串结尾string& append(const string& s);//同operator+=(const string& str);string& append(const string& s, int pos, int n);//字符串从 pos 开始的 n 个字符连接到字符串结尾。
示例：
#include 总结：字符串拼接的重载版本很多，初学阶段记住几种即可。
1.5 string 查找和替换
功能描述：
- 查找：查找指定字符串是否存在
- 替换：在指定位置替换字符串
函数原型：
-
int find(const string& str, int pos = 0) const;//查找 str 第一次出现位置，从 pos 开始查找 -
int find(const char* s, int pos = 0) const;//查找 s 第一次出现位置，从 pos 开始查找 -
int find(const char* s, int pos, int n) const;//从 pos 位置查找 s 的前 n 个字符第一次位置 -
int find(const char c, int pos = 0) const;//查找字符 c 第一次出现位置 -
int rfind(const string& str, int pos = npos) const;//查找 str 最后一次位置，从 pos 开始查找 -
int rfind(const char* s, int pos = npos) const;//查找 s 最后一次位置，从 pos 开始查找 -
int rfind(const char* s, int pos, int n) const;//从 pos 位置查找 s 的前 n 个字符最后一次位置 -
int rfind(const char c, int pos = 0) const;//查找字符 c 最后一次出现位置 -
string& replace(int pos, int n, const string& str);//替换从 pos 开始 n 个字符为字符串 str -
string& replace(int pos, int n, const char* s);//替换从 pos 开始 n 个字符为字符串 s
示例：
#include 总结：
- find 从左往右查找，rfind 从右往左查找
- find 找到字符串后返回查找的第一个字符位置，找不到返回 -1
- replace 替换时，要指定从哪个位置起，多少个字符，替换成怎么样的字符串，并且要替换的字符串无论多少个字符，都会替换进去
1.6 string 字符串比较
功能描述：
- 字符串之间的比较
比较方式：
- 字符串比较是按字符的 ASCII 码进行对比
- = 返回 0
-
返回 1
- < 返回 -1
函数原型：
int compare(const string& s) const;//与字符串 s 比较int compare(const char* s) const;//与字符串 s 比较
示例：
#include 总结：
- 字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小意义并不是很大
1.7 string 字符存取
string 中单个字符存取方式有两种。
- char& operator[](int n);//通过 [] 方式取字符
- char& at(int n);//通过 at 方式获取字符
示例：
#include 总结：string 字符串中单个字符存取有两种方式，利用 [ ] 或 at
1.8 string 插入和删除
功能描述：
- 对 string 字符串进行插入和删除字符操作
函数原型：
- string& insert(int pos, const char* s);//插入字符串
- string& insert(int pos, const string& str);//插入字符串
- string& insert(int pos, int n, char c);//在指定位置插入 n 个字符 c
- string& erase(int pos, int n = npos);//删除从 Pos 开始的 n 个字符
示例：
#include 总结：插入和删除的起始下标都是从 0 开始。
1.9 string 子串
功能描述：
- 从字符串中获取想要的子串
函数原型：
- string substr(int pos = 0, int n = npos) const;//返回由 pos 开始的 n 个字符组成的字符串
示例：
#include 实例：
#include 总结：灵活的运用求子串功能，可以在实际开发中获取有用的信息。
2. vector 容器
2.1 vector 基本概念
功能：
- vector 数据结构和数组非常相似，也成为单端数组。
vector 与 普通数组区别：
- 不同之处在于数组是静态空间，而 vector 可以动态扩展。
动态扩展：
- 并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间。
- vector 容器的迭代器是支持随机访问的迭代器
2.2 vector 构造函数
功能描述：
- 创建 vector 容器
函数原型：
vector// 采用模板实现类实现，默认构造函数v; vector(v.begin(), v.end());//将 v[begin(), end()) 区间中的元素拷贝给本身
是一个前闭后开区间，begin() 的值可以取到，end() 的值是取不到的。（因为 end() 的值没有意义，不是我们想要的）
vector(n, elem);//构造函数将 n 个 elem 拷贝给本身vector(const vector& vec);//拷贝构造函数
示例：
#include 总结：vector 的多种构造方式没有可比性，灵活使用即可。
2.3 vector 赋值操作
功能描述：
- 给 vector 容器进行赋值
函数原型：
vector& operator=(const vector& vec);// 重载等号操作符assign(beg, end);//将 [beg, end) 区间中的元素拷贝赋值给本身assign(n, elem);//将 n 个 elem 拷贝赋值给本身
示例：
#include 总结：vector 赋值方式比较简单，使用 operator=，或者 assign 都可以
2.4 vector 容量和大小
功能描述：
- 对 vector 容器的容量和大小操作
函数原型：
empty();// 判断容器是否为空capacity;// 容器的容量size();// 返回容器中元素的个数
容量永远都 大于等于 大小。
resize(int num);// 重新指定容器的长度为 num，若容器变长，则以默认值填充新位置，若容器变短，则末尾超出容器长度的元素被删除。resize(int num, elem);// 重新指定容器的长度为 num，若容器变长，则以 elem 值填充新位置，若容器变短，则末尾超出容器长度的元素被删除。
示例：
#include 总结：
- 判断是否为空 — empty
- 返回元素个数 — size
- 返回容器容量 — capacity
- 重新指定大小 — resize
2.5 vector 插入和删除
功能描述：
- 对 vector 容器进行插入、删除操作
函数原型：
push_back(ele);//尾部插入元素 elepop_back();//删除最后一个元素insert(const_iterator pos, ele);//迭代器指向位置 pos 插入元素 eleinsert(const_iterator pos, int count, ele);//迭代器指向位置 pos 插入 count 个元素 eleerase(const_iterator pos);//删除迭代器指向的元素erase(const_iterator start, const_iterator end);//删除迭代器从 start 到 end 之间（[start, end)）的元素
插入（insert）和删除（erase）都必须要提供迭代器，而不能是提供下标。
clear();//删除容器中所有元素
示例：
#include 总结：
- 尾插 — push_back
- 尾删 — pop_back
- 插入 — insert（位置迭代器）
- 删除 — erase（位置迭代器）
- 清空 — clear
2.6 vector 数据存取
功能描述：
- 对 vector 中的数据的存取操作
函数原型：
at(int idx);//返回索引 idx 所指的数据operator[];//返回索引 idx 所指的数据front();//返回容器中第一个数据元素back();//返回容器中最后一个数据元素
示例：
#include 总结：
- 除了用迭代器获取 vector 容器中元素，[] 和 at 也可以
- front 返回容器第一个元素
- back 返回容器最后一个元素
2.7 vector 互换容器
功能描述：
- 实现两个容器的元素进行交换
函数原型：
swap(vec);//将 vec 与本身的元素互换
示例：
#include 实例：巧用 swap 可以收缩内存空间。
#include
- 创建一个匿名容器，调用拷贝构造函数，用 v 目前所用的元素个数来初始化，所以匿名容器的容量是 3，大小也是 3。
- 调用 swap 函数将 匿名容器与 v 容器做了交换，所以 v 的容量是 3，大小也是 3。
- 匿名容器在当前行执行完之后所占的内存由系统马上回收。
总结：swap 可以使两个容器互换，可以达到实用的收缩内存的效果。
2.8 vector 预留空间
功能描述：
- 减少 vector 在动态扩展容量时的扩展次数
函数原型：
reserve(int len);//容器预留 len 个元素长度，预留位置不初始化，元素不可访问。
示例：
#include 总结：如果数据量较大，可以一开始利用 reserve 预留空间。
3. deque 容器
3.1 deque 容器基本概念
功能：
- 双端数组，可以对头端进行插入删除操作
deque 与 vector 区别：
- vector 对于头部的插入删除需要移动元素，效率低，数据量越大，效率越低
- deque 相对而言，对头部的插入删除速度会比 vector 快。
- vector 访问元素时的速度会比 deque 快，这和两者的内部实现有关
deque 内部工作原理：
deque 内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据。
中控器维护的是每个缓冲区的地址，使得使用 deque 时像一片连续的内存空间。
当缓冲区中数据（头部/尾部）插满以后，再有新的数据插入时，会再申请一块新的缓冲区，插入数据进去，并在中控器中记录缓冲区的地址。
所以它对头部和尾部都可以快速的插入删除。只不过访问数据的速度没有 vector 那么快，因为需要通过中控器并且跨缓冲区来访问数据，访问效率较低。
- deque 容器的迭代器也是支持随机访问的。
3.2 deque 构造函数
功能描述：
- deque 容器构造
函数原型：
deque//默认构造函数deqT; deque(deq.begin(), deq.end());//构造函数将 [begin(), end()) 区间中的元素拷贝给本身deque(n, elem);//构造函数将 n 个 elem 拷贝给本身deque(const deque& deq);//拷贝构造函数
示例：
#include 只读容器要使用只读迭代器 (const_iterator) 来访问。
总结：deque 容器和 vector 容器的构造方式几乎一致，灵活使用即可。
3.3 deque 赋值操作
功能描述：
- 给 deque 容器进行赋值
函数原型：
deque& operator=(const deque& deq);// 重载等号操作符assign(beg, end);//将 [beg, end) 区间中的元素拷贝赋值给本身assign(n, elem);//将 n 个 elem 拷贝赋值给本身
示例：
#include 总结：deque 赋值操作也与 vector 相同，需熟练掌握。
3.4 deque 大小操作
功能描述：
- 对 deque 容器的大小操作
函数原型：
empty();// 判断容器是否为空size();// 返回容器中元素的个数resize(int num);// 重新指定容器的长度为 num，若容器变长，则以默认值填充新位置，若容器变短，则末尾超出容器长度的元素被删除。resize(int num, elem);// 重新指定容器的长度为 num，若容器变长，则以 elem 值填充新位置，若容器变短，则末尾超出容器长度的元素被删除。
deque 容器没有容量的概念，因为它的内部结构中根本没有容量这一个限制，它可以往后面开辟新的缓冲区，中控区只加一个地址就可以了，维护开辟的缓冲区。
示例：
#include 总结：
- deque 没有容量的概念
- 判断是否为空 — empty
- 返回元素个数 — size
- 重新指定大小 — resize
3.5 deque 插入和删除
功能描述：
- 对 deque 容器进行插入、删除操作
函数原型：
两端插入操作：
push_back(elem);//尾部插入元素 elempush_front(elem);//头部插入元素 elempop_back();//删除最后一个元素pop_front();//删除第一个元素
指定位置操作：
insert(pos, elem);//在 pos 位置插入元素 elem，返回新数据的位置insert(pos, num, elem);//在 pos 位置插入 num 个元素 elem，无返回值insert(pos, beg, end);//在 pos 位置插入 [beg, end) 区间的数据，无返回值。erase(pos);//删除 pos 位置的元素，返回下一个数据的位置erase(start, end);//删除 [start, end) 区间的数据，返回下一个数据的位置
插入（insert）和删除（erase）都必须要提供迭代器，而不能是提供下标。
clear();//清空容器中所有元素
示例：
#include 总结：
- 插入和删除提供的位置都是迭代器！
- 尾插 — push_back
- 尾删 — pop_back
- 头插 — push_front
- 头删 — pop_front
3.6 deque 数据存取
功能描述：
- 对 deque 中的数据的存取操作
函数原型：
at(int idx);//返回索引 idx 所指的数据operator[];//返回索引 idx 所指的数据front();//返回容器中第一个数据元素back();//返回容器中最后一个数据元素
示例：
#include 总结：
- 除了用迭代器获取 deque 容器中元素，[] 和 at 也可以
- front 返回容器第一个元素
- back 返回容器最后一个元素
3.7 deque 排序
功能描述：
- 利用算法实现对 deque 容器进行排序
算法：
sort(iterator beg, iterator end);//对 beg 和 end 区间内元素进行排序
示例：
#include
- 对于支持随机访问的迭代器的容器，都可以利用 sort 算法直接对其进行排序。
- sort 算法的默认排序规则是升序排列（从小到大）。
总结：sort 算法非常实用，使用时包含头文件 algorithm 即可。
4. stack 容器
4.1 stack 基本概念
概念：stack 是一种先进后出（First In Last Out, FILO）的数据结构，它只有一个出口。
栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为。
栈中进入数据称为 — 入栈 push
栈中弹出数据称为 — 出栈 pop
栈可以判断容器是否为空么？— 可以（empty）
栈可以返回元素个数么？— 可以（size）
4.2 stack 常用接口
功能描述：栈容器常用的对外接口
构造函数：
- stack stk; //stack 采用模板类实现，stack 对象的默认构造形式
- stack(const stack& stk); //拷贝构造函数
赋值操作：
- stack& operator=(const stack& stk); //重载等号操作符
数据存取：
- push(elem); //向栈顶添加元素
- pop(); //从栈顶移除第一个元素
- top(); //返回栈顶元素
大小操作：
- empty(); //判断堆栈是否为空
- size(); //返回栈的大小
#include 总结：
- 入栈 — push
- 出栈 — pop
- 返回栈顶 — top
- 判断栈是否为空 — empty
- 返回栈大小 — size
5. queue 容器
5.1 queue 基本概念
概念：queue 是一种先进先出（First In First Out, FIFO）的数据结构，它只有一个出口。
队列容器允许从一端新增元素，从另一端移除元素。
队列中只有队头和队尾可以被外界使用，因此队列不允许有遍历行为。
队列中进数据称为 — 入队 push
队列中出数据称为 — 出队 pop
5.2 queue 常用接口
功能描述：队列容器常用的对外接口
构造函数：
- queue que; //queue 采用模板类实现，queue 对象的默认构造形式
- queue(const queue& que); //拷贝构造函数
赋值操作：
- queue& operator=(const queue& que); //重载等号操作符
数据存取：
- push(elem); //往队尾添加元素
- pop(); //从队头移除第一个元素
- back(); //返回最后一个元素
- front(); //返回第一个元素
大小操作：
- empty(); //判断队列是否为空
- size(); //返回队列的大小
#include 总结：
- 入队 — push
- 出队 — pop
- 返回队头元素 — front
- 返回队尾元素 — back
- 判断队列是否为空 — empty
- 返回队列大小 — size
6. list 容器
6.1 list 容器基本概念
功能：将数据进行链式存储
概念：链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。
- 链表的组成：链表有一系列结点组成
- 节点的组成：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域。
STL 中的链表是一个双向循环链表。
- 双向：结点的指针域中有两个指针，一个指针指向前一个结点（prev），一个指针指向后一个结点（next），每个结点既记录了上一个结点，又记录了下一个结点。
- 循环：最后一个结点的下一个结点记录第一个结点（next 指针指向第一个结点），第一个结点的前一个结点记录最后一个结点（prev 指针指向最后一个结点）。
由于链表的存储方式并不是连续的内存空间，因此链表 list 中的迭代器只支持前移和后移，属于双向迭代器。
迭代器只能通过指针域一个一个找，不能跳跃式访问
list 的优点：
- 采用动态存储分配，不会造成内存浪费和溢出
- 链表可以对任意位置快速插入和删除元素，执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
list 的缺点：
- 链表灵活，但是空间（指针域）和时间（遍历）额外耗费较大
链表的遍历速度没有数组快，需要通过指针域不断的访问下一个元素。
list 有一个重要的性质，插入操作和删除操作都不会造成原有 list 迭代器失效，这在 vector 是不成立的。（vector 容器在动态扩展的过程中会使原有迭代器失效）
总结：STL 中 list 和 vector 是两个最常被使用的容器，各有优缺点。
6.2 list 构造函数
功能描述：
- 创建 list 容器
函数原型：
list// list 采用模板类实现，对象的默认构造方式lst; list(beg, end);// 构造函数将 [beg, end) 区间中的元素拷贝给本身list(n, elem);// 构造函数将 n 个 elem 元素拷贝给本身list(const list& lst);// 拷贝构造函数
示例：
#include
using namespace std;
void printList(const list<int>& l) {
for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main() {
list<int> l1;//1.默认构造
l1.push_back(10);
l1.push_back(30);
l1.push_back(20);
l1.push_back(40);
printList(l1);
list<int> l2(l1.begin(),l1.end());//2.
printList(l2);
list<int> l3(5, 10);//3.
printList(l3);
list<int> l4(l2);//4.
printList(l4);
return 0;
}
总结：list 构造方式同其他几个 STL 常用容器，熟练掌握即可
6.3 list 赋值和交换
功能描述：
- 给 list 容器进行赋值，以及交换 list 容器
函数原型：
list& operator=(const list& lst);// 重载等号操作符assign(beg, end);//将 [beg, end) 区间中的元素拷贝赋值给本身assign(n, elem);//将 n 个 elem 拷贝赋值给本身swap(lst);//将 list 与本身的元素互换
示例：
#include
using namespace std;
void printList(const list<int>& l) {
for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//list 赋值和交换操作
int main() {
list<int> l1;
for (int i = 0; i < 10; i++) {
l1.push_back(i);
}
printList(l1);
list<int> l2;
l2 = l1;//1.
printList(l2);
list<int> l3;
l3.assign(l1.begin(), l1.end());//2.
printList(l3);
list<int> l4;
l4.assign(10, 100);//3.
printList(l4);
l3.swap(l4);//4.
printList(l3);
printList(l4);
return 0;
}
总结：list 赋值和交换操作能够灵活运用即可
6.4 list 大小操作
功能描述：
- 对 list 容器的大小操作
函数原型：
empty();// 判断容器是否为空size();// 返回容器中元素的个数resize(int num);// 重新指定容器的长度为 num，若容器变长，则以默认值填充新位置，若容器变短，则末尾超出容器长度的元素被删除。resize(int num, elem);// 重新指定容器的长度为 num，若容器变长，则以 elem 值填充新位置，若容器变短，则末尾超出容器长度的元素被删除。
示例：
#include
using namespace std;
void printList(const list<int>& l) {
for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//list 容量和大小
int main() {
list<int> l1;
for (int i = 0; i < 10; i++) {
l1.push_back(i);
}
printList(l1);
if (l1.empty()) {//1.
cout << "l1 为空" << endl;
}
else {
cout << l1.size() << endl;//2.//10
}
l1.resize(5);//3.如果重新指定的比原来短了，超出的部分会删除掉
printList(l1);
l1.resize(10, 100);//4.指定默认的填充值（不指定默认为 0），如果重新指定比原来长，用默认的填充值填充新的位置
printList(l1);
return 0;
}
总结：
- 判断是否为空 — empty
- 返回元素个数 — size
- 重新指定大小 — resize
6.5 list 插入和删除
功能描述：
- 对 list 容器进行插入、删除操作
函数原型：
push_back(elem);//容器尾部插入元素 elempush_front(elem);//容器开头插入元素 elempop_back();//删除容器最后一个元素pop_front();//从容器开头移除第一个元素insert(pos, elem);//在 pos 位置插入 elem 元素的拷贝，返回新数据的位置insert(pos, num, elem);//在 pos 位置插入 num 个 elem 数据，无返回值insert(pos, beg, end);//在 pos 位置插入 [beg, end) 区间的数据，无返回值。erase(pos);//删除 pos 位置的元素，返回下一个数据的位置erase(start, end);//删除 [start, end) 区间的数据，返回下一个数据的位置
插入（insert）和删除（erase）都必须要提供迭代器，而不能是提供下标。
remove(elem);//删除容器中所有与 elem 值匹配的元素clear();//移除容器中所有数据
示例：
#include
using namespace std;
void printList(const list<int>& l) {
for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//deque 插入和删除操作
int main() {
list<int> l1;
for (int i = 0; i < 10; i++) {
l1.push_back(i);//1.尾插
l1.push_front(i + 10);//2.头插
}
printList(l1);
l1.pop_back();//3.尾删
l1.pop_front();//4.头删
printList(l1);
l1.inert(l1.begin(), 100);//1.插入
printList(l1);
l1.inert(l1.begin(), 2,1000);//2.插入
printList(l1);
list<int> l2;
l2.push_back(1);
l2.push_back(1);
l2.push_back(1);
l1.inert(l1.begin(), l2.begin(), l2.end());//3.按照区间插入
printList(l1);
l2.erase(++l2.begin());//4.删除
printList(l2);
l2.erase(l2.begin(), l2.end());//5.按照区间删除
printList(l2);
l1.remove(1);//6.移除容器中所有匹配元素
printList(l1);
l1.clear();//7.清空
printList(l1);
return 0;
}
双向迭代器支持 ++、–。
总结：
- 尾插 — push_back
- 尾删 — pop_back
- 头插 — push_front
- 头删 — pop_front
- 插入 — insert
- 删除 — erase
- 移除 — remove
- 清空 — clear
6.6 list 数据存取
功能描述：
- 对 list 中的数据的存取操作
函数原型：
front();//返回容器中第一个数据元素back();//返回容器中最后一个数据元素
示例：
#include
using namespace std;
void printList(const list<int>& l) {
for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//list 的数据存取操作
int main() {
list<int> l1;
for (int i = 0; i < 10; i++) {
l1.push_back(i);
}
printDeque(v1);
l1.front();//1.
l1.back();//2.
return 0;
}
不可以用 [] 和 at 访问 list 容器中的元素！
原因：list 本质链表，不是用连续线性空间存储数据；迭代器是双向迭代器，也是不支持随机访问的。因此不能跳跃式的访问容器中的元素。
验证迭代器不支持随机访问：
list<int>::iterator it = l1.begin();
it++;//如果即支持 ++ 又支持 -- 是双向迭代器
it--;//如果只支持 ++ 不支持 -- 就是前向迭代器
//it = it + 1;//不支持随机访问
总结：
- front 返回容器第一个元素
- back 返回容器最后一个元素
6.7 list 反转和排序
功能描述：
- 将容器中的元素反转，以及将 list 容器中的数据进行排序
算法：
- reverse(); //反转链表
sort();//链表排序
示例：
#include
using namespace std;
void printList(const list<int>& l) {
for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
bool myCompare(int v1, int v2) {
//降序：就让第一个数 > 第二个数
return v1 > v2;
}
int main() {
list<int> l1;
l1.push_back(10);
l1.push_back(30);
l1.push_back(20);
l1.push_back(40);
printList(l1);
//反转
l1.reverse();
printList(l1);
//排序
l1.sort();//默认排序规则是升序排列（从小到大）
printList(l1);
//降序
l1.sort(myCompare);//指定排序规则
printList(l1);
return 0;
}
- 所有不支持随机访问迭代器的容器，不可以用标准算法
- 不支持随机访问迭代器的容器，内部会提供一些对应的成员函数的一些算法
- 排序函数会根据容器的个数选择适应的排序算法，如果数据量级大了，有一套自己的排序规则；如果数据量级小了，它又换一套排序规则，会根据你的数据量级做一个选择性的排序算法。
总结：
- 反转 — reverse
- 排序 — sort（成员函数）
6.8 list 排序自定义类型数据
功能描述：
- 将存放f自定义类型数据的 list 容器进行排序
案例描述：
- 将 Person 自定义类型数据进行排序，Person 中属性有姓名、年龄、身高
排序规则：
- 按照年龄进行升序，如果年龄相同按照身高进行降序
示例：
#include
using namespace std;
class Person {
public:
Person(string name, int age, int height) {
m_Name = name;
m_Age = age;
m_Height = height;
}
public:
string m_Name;
int m_Age;
int m_Height;
};
void printList(const list<Person>& l) {
for (list<Person>::const_iterator it = l.begin(); it != l.end(); it++) {
cout << it->m_Name << " "<< it->m_Age << " "<< it->m_Height << " ";
}
cout << endl;
}
bool myCompare(Person& p1, Person& p2) {
// 按照年龄 排序
if (p1.m_Age == v2.m_Age) {
// 年龄相同 按照身高排序
return p1.m_Height > p2.m_Height;
} else {
return p1.m_Age < v2.m_Age;
}
}
int main() {
list<int> l1;
Person p1("zhao", 35, 175);
Person p2("qian", 45, 180);
Person p3("sun", 40, 170);
Person p4("li", 25, 190);
Person p5("zhou", 35, 160);
Person p6("wu", 35, 200);
l1.push_back(p1);
l1.push_back(p2);
l1.push_back(p3);
l1.push_back(p4);
l1.push_back(p5);
l1.push_back(p6);
printList(l1);
//排序
l1.sort(myCompare);
printList(l1);
return 0;
}
- 对于 list 容器而言，如果存放的是自定义数据类型，排序时必须指定排序规则，否则编译器不知道如何进行排序
- 高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂
7. set/multiset 容器
7.1 set 基本概念
特点：
- 所有元素都会在插入时自动被排序
本质：
- set/multiset 属于关联式容器，底层结构是用二叉树实现的。
关联式容器的特点就是在插入时自动排序。
set 和 multiset 区别：
- set 不允许容器中有重复的元素
- multiset 允许容器中有重复的元素
使用这两个容器需要包含头文件
#include
7.2 set 构造和赋值
功能描述：
- 创建 set 容器以及赋值
构造：
set//默认构造函数st; set(const set& st);//拷贝构造函数
赋值：
set& operator=(const set& st);//重载等号操作符
示例：
#include 总结：
- set 容器插入数据的时候只有 insert 的方式。
- set 容器插入数据的数据会自动排序。
7.3 set 大小和交换
功能描述：
- 统计 set 容器大小以及交换 set 容器
函数原型：
size();//返回容器中元素的数目empty();//判断容器是否为空swap(st);//交换两个集合容器
set 容器不允许重新指定大小，因为 set 容器不允许有重复的元素，而重新指定大小时的默认填充元素是重复的元素，没有意义。
示例：
#include 总结：
- 统计大小 — size
- 判断是否为空 — empty
- 交换容器 — swap
7.4 set 插入和删除
功能描述：
- set 容器进行插入数据和删除数据
函数原型：
insert(elem);//在容器中插入元素clear();//清除所有元素erase(pos);//删除 pos 迭代器所指的元素，返回下一个元素的迭代器erase(beg, end);//删除区间 [beg, end) 的所有元素，返回下一个元素的迭代器erase(elem);//删除容器中值为 elem 的元素
set 容器的删除函数的参数可以不提供迭代器，而是提供一个元素，它会把指定的元素给删掉。
示例：
#include 总结：
- 插入 — insert
- 删除 — erase
- 清空 — clear
7.5 set 查找和统计
功能描述：
- set 容器进行查找数据和统计数据
函数原型：
find(key);//以迭代器的方式查找 key 是否存在，若存在，返回该键的元素的迭代器；若不存在，返回 set.end();count(key);//统计 key 的元素个数，对于 set 容器而言，结果是 0 或者 1，因为 set 容器不允许有重复的元素，对于 multiset 容器而言，返回结果可能会 > 1。
示例：
#include 总结：
- 查找 — find（返回的是迭代器）
- 统计 — count（对于 set，结果为 0 或者 1）
7.6 set 和 multiset 区别
学习目标：
- 掌握 set 和 multiset 的区别
区别：
- set 不可以插入重复数据，而 multiset 可以
- set 插入数据的同时会返回插入结果，表示插入是否成功
- multiset 不会检测数据，因此可以插入重复数据
示例：
#include set 容器在插入时会返回一个对组，对组中第一个数据是一个迭代器，会返回元素插入的位置，第二个数据是 一个 bool 数据类型的数据，代表数据是否插入成功。所以对于我们而言，set 容器在插入的时候会告诉你一个数据插入成功还是失败的一个结果。所以它会有插入重复检测。
multiset 容器在插入时会返回一个迭代器，只要插入的数据的类型正确，就会返回元素插入的位置，所以它没有插入重复检测，允许插入重复的数据。
总结：
- 如果不允许插入重复数据可以利用 set
- 如果需要插入重复数据利用 multiset
7.7 pair 对组的创建
功能描述：
- 成对出现的数据，利用对组可以返回两个数组
两种创建方式：
pairpair
示例：
#include 总结：两种方式都可以创建对组，记住一种即可。
7.8 set 容器排序
功能描述：
- set 容器默认排序规则是从小到大，掌握如何改变排序规则
set 容器如果想要改变容器的排序规则，就要在插入前就指定容器的排序规则。
主要技术点：
- 利用仿函数，可以改变排序规则
仿函数就是重载了函数调用运算符() 的类，本质是一个类型。
示例一：set 存放内置数据类型
#include
- 模板参数列表中要放类型，不能放函数名
- 如果用函数打印容器中的数据，得把仿函数写在前面，写声明不行
- 仿函数必须用 const 修饰
- 一般三种方式实现自己的比较器 lambda函数，仿函数，运算符重载
总结：利用仿函数可以指定 set 容器的排序规则
示例二：set 存放自定义数据类型
#include
- 仿函数在了类和使用之间
- 参数const 引用，不会导致拷贝构造出现
- 存放自定义数据类型的 set 容器必须指定排序规则。
总结：对于自定义数据类型，set 必须指定排序规则才可以插入数据
8. map/ multimap 容器
使用率仅次于 vector 和 list，在 STL 中地位比较高，STL 有一个优点叫高性能高效率说的就是 map 容器。
8.1 map 基本概念
简介：
- map 中所有元素都是 pair
- pair 中第一个元素为 key（键值），起到索引作用，第二个元素为 value（实值）
- 所有的元素都会根据元素的键值自动排序
高性能：可以快速地从大量的数据中找到想要的数据，因为 key 起到了索引作用。
本质：
- map/multimap 属于关联式容器，底层结构是用二叉树实现。
优点：
- 可以根据 key 值快速找到 value 值
map 和 multimap 区别：
- map 不允许容器中有重复 key 值元素
- multimap 允许容器中有重复 key 值元素
map 不允许插入重复的元素，后插的重复元素不会插入进去。
8.2 map 构造和赋值
功能描述：
- 对 map 容器进行构造和赋值操作
函数原型：
构造：
map// map 默认构造函数map(const map& mp);// 拷贝构造函数
赋值：
map& operator=(const map& mp);//重载等号操作符
示例：
#include 总结：map 中所有元素都是成对出现，插入数据时要使用对组
8.3 map 大小和交换
功能描述：
- 统计 map 容器大小以及交换 map 容器
函数原型：
size();// 返回容器中元素的数目empty();// 判断容器是否为空swap(st);//交换两个集合容器
示例：
#include 总结：
- 统计大小 — size
- 判断是否为空 — empty
- 交换容器 — swap
8.4 map 插入和删除
功能描述：
- map 容器进行插入数据和删除数据
函数原型：
insert(elem);// 在容器中插入元素clear();// 清除所有元素erase(pos);//删除 pos 迭代器所指的元素，返回下一个元素的迭代器erase(beg, end);//删除区间 [beg, end) 的所有元素，返回下一个元素的迭代器erase(key);//删除容器中值为 key 的元素
map 容器的删除函数的参数可以不提供迭代器，而是提供一个元素，它会把 key值为指定元素的对组 给删掉。
示例：
#include
cout << m[5] << endl;
如果没有在容器中找到 key 为 5的对组，会自动创建一个 key 为 5，value 为 0 的对组插入到容器中，最终在容器中找到 key 为 5 的对组，返回 value 0。- [ ]不建议用于插入，用途：可以利用 key 访问到 value。
总结：
- map 插入方式很多，记住其一即可
- 插入 — insert
- 删除 — erase
- 清空 — clear
8.5 map 查找和统计
功能描述：
- 对 map 容器进行查找数据以及统计数据
函数原型：
find(key);// 以迭代器的方式查找 key 是否存在，若存在，返回该键的元素的迭代器；若不存在，返回 set.end();count(key);//统计 key 的元素个数，对于 map 容器而言，结果是 0 或者 1，因为 map 容器不允许有重复的 key 元素，对于 multimap 容器而言，返回结果可能会 > 1。
示例：
#include map 不允许插入重复的 key 元素，后插入的重复元素会插入不进去（不是覆盖）。
总结：
- 查找 — find（返回的是迭代器）
- 统计 — count（对于 map，结果为 0 或者 1）
8.6 map 容器排序
功能描述：
- map 容器默认排序规则为按照 key 值进行从小到大排序，掌握如何改变排序规则
主要技术点：
- 利用仿函数，可以改变排序规则
示例：
#include 总结：
- 利用仿函数可以指定 map 容器的排序规则
- 对于自定义数据类型，map 必须要指定排序规则，同 set 容器