STL总结

STL

STL，标准模板库，包含多种容器。

1 栈 stack

先进后出。

头文件：#include <stack>

操作	含义
stack<int> s	定义一个 int 数据类型的栈
s.top()	获取栈顶元素
s.pop()	弹出元素
s.push(i)	放入元素 i
s.size()	获取栈的元素个数
s.empty()	判断栈是否为空（返回 bool 类型）

2 队列 queue

2.1 队列 queue

先进先出。

头文件：#include <queue>

操作	含义
queue<int> q	定义一个 int 数据类型的队列
q.front()	获取队头元素
q.back()	获取队尾元素
q.pop()	弹出元素
q.push(i)	放入元素 i
q.size()	获取队列的元素个数
q.empty()	判断队列是否为空（返回 bool 类型）

2.2 双端队列 deque

与队列操作部分相同，但不同点是，双端队列队头队尾都可以进行操作。

头文件：#include <deque>

操作	含义
deque<int> dq	定义一个 int 数据类型的双向队列
dq.push_back(i)	队尾放入元素 i
dq.push_front(i)	队头放入元素 i
dq.pop_back()	队尾弹出元素
dq.pop_front()	队头弹出元素

3 向量 vector

3.1 迭代器 iterator

访问STL容器元素的变量，与指针类似。

定义方法：容器类型::iterator 迭代器名

3.2 向量 vector

又称动态数组。

头文件：#include <vector>

操作	含义
vector<int> v	定义一个 int 数据类型的向量
vector<int> v(len)	定义一个有 len 个 int 数据类型的元素的向量
vector<int> v(len, t)	定义一个有 len 个 int 数据类型的元素的向量，且元素全部初始化为 t
v.front()	获取第一个元素
v.back()	获取最后一个元素
v[i]	获取下标为 i 的元素（与数组相同）
v.push_back(i)	在最后插入元素 i
v.pop_back()	删除最后一个元素
v.insert(it, i)	在迭代器 it 的后面插入元素 i
v.erase(it)	删除迭代器 it 所指向的元素
v.size()	获取向量的元素个数
v.empty()	判断向量是否为空（返回 bool 类型）
v.begin()	获取向量的起始地址（迭代器）
v.end()	获取向量的结束地址（迭代器）
v.clear()	清空向量所有元素
vector<int>::iterator it	定义一个 vector<int> 类型的迭代器
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)	使用迭代器遍历向量
*it	获取迭代器所指向的元素的值

4 对 pair

由两个值组成。

头文件：#include <pair>

操作	含义
pair<int, int> p	定义一个两个元素都是 int 数据类型的向量
pair<int, int> p(x, y)	定义一个两个元素都是 int 数据类型的向量，并初始化为 $(x,y)$
p.first	第一个元素
p.second	第二个元素
make_pair(x, y)	创建一个 pair 对象

5 映射 map

5.1 映射 map

map 反映的是一种映射关系，即一种类型的值对应另一种类型的一个值。

一个 map 有两个值，前者是键 key，后者是值 value，可以通过键来查找值，但不可以通过值直接查找键。每一个键只有一个值与之对应，且键是唯一存在的。

map 默认以键来排序。map 的底层实现是红黑树。

头文件：#include <map>

操作	含义
map<int, int> mp	定义一个键和值都是 int 数据类型的map
mp[key]	获取键为 key 的值
mp.insert(i)	在后面插入键值对 i（pair类型，可使用 make_pair(key, value)）
mp.insert(it, i)	在迭代器 it 的后面插入键值对 i（pair类型，可使用 make_pair(key, value)
mp.erase(it)	删除迭代器 it 所指向的键值对
mp.erase(key)	删除键为 key 的值
mp.size()	获取map的元素个数
mp.count(key)	返回键为 key 的值的个数（因为键只有一个值，所以返回只能是 1 或 0）
mp.empty()	判断map是否为空（返回 bool 类型）
mp.begin()	获取map的起始地址（迭代器）
mp.end()	获取map的结束地址（迭代器）
mp.clear()	清空map所有元素
map<int, int>::iterator it	定义一个 map<int, int> 类型的迭代器
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); it++)	使用迭代器遍历 map
it->first	获取迭代器所指向的元素的键
it->second	获取迭代器所指向的元素的值

5.2 重复映射 multimap

与 map 的不同点在于，相同的键可以有多组键值对。

注意，multimap 并没有对 []重载运算符，不能使用mp[key]的方法获取、操作值。

multimap 涵盖在头文件 <map> 中。

操作	含义
multimap<int, int> mp	定义一个键和值都是 int 数据类型的 multimap
mp.count(key)	返回键为 key 的值的个数
multimap<int, int>::iterator it	定义一个 multimap<int, int> 类型的迭代器
for (multimap<int, int>::iterator it = mp.begin(); it != mp.end(); it++)	使用迭代器遍历 multimap

5.3 无序映射 unordered_map

与 map 的不同点在于，不进行自动排序。

map的底层实现是哈希 hash。

头文件：#include <unordered_map>

操作	含义
unordered_map<int, int> mp	定义一个键和值都是 int 数据类型的unordered_map
unordered_map<int, int>::iterator it	定义一个 unordered_map<int, int> 类型的迭代器
for (unordered_map<int, int>::iterator it = mp.begin(); it != mp.end(); it++)	使用迭代器遍历 unordered_map

6 集合 set

6.1 集合 set

可自动去重、排序的容器。

set 的底层实现是红黑树。

头文件：#include <set>

操作	含义
set<int> s	定义一个 int 数据类型的 set
s.insert(i)	放入元素 i
s.erase(i)	删除元素 i，返回1，若无此元素，返回0
s.clear()	清空 set
s.empty()	判断set是否为空（返回 bool 类型）
s.size()	set的元素个数
s.begin()	set的起始地址（迭代器）
s.end()	set的结束地址（迭代器）
s.find(i)	set 中寻找i元素，有则返回迭代器，无则返回 s.end()
set<int>::iterator it	定义一个 set<int> 类型的迭代器
for (set<int>::iterator it = s.begin(); it != s.end(); it++)	使用迭代器遍历 set
*it	获取迭代器指向的值

6.2 不去重集合 multiset

与 set 的不同点在于，不对元素进行自动去重操作。

multiset 涵盖在头文件 <set> 中。

操作	含义
multiset<int> s	定义一个 int 数据类型的 multiset
multiset<int>::iterator it	定义一个 multiset<int> 类型的迭代器
for (multiset<int>::iterator it = s.begin(); it != s.end(); it++)	使用迭代器遍历 multiset

6.3 无序集合 unordered_set

与 set 的不同点在于，不进行自动排序操作。

unordered_set 的底层实现是哈希 hash。

头文件：unordered_set

操作	含义
unordered_set<int> s	定义一个 int 数据类型的unordered_map
unordered_set<int>::iterator it	定义一个 unordered_set<int> 类型的迭代器
for (unordered_set<int>::iterator it = s.begin(); it != s.end(); it++)	使用迭代器遍历 unordered_set