【C/C++】常用STL容器

vector容器

使用时需要引用头文件:#include <vector>
定义：

vector<数据类型> 变量名;
// 如
vector<int> v;

访问容器中的元素：
1.通过下标访问，和数组一样.
2.通过迭代器访问，迭代器类似指针
定义迭代器，访问迭代器指向的元素

vector<数据类型>::iterator 指针名;

// 例子
vector<int>:: iterator it = v.begin(); // v.begin()为容器中第一个元素的地址
// 假设此时容器v中有{1,0,0,8,6}这些元素
// *it则为元素1
// *(it+1)则为元素0
cout<<*it<<endl; // 输出1
cout<<*(it+1)<<endl; // 输出0

常用函数：

v.push_back(x); // 在容器v末尾添加元素x，时间复杂度O(1)
v.pop_back(); // 删除容器v末尾的元素，时间复杂度O(1)
v.size(); // 返回值为容器v的元素个数
v.clear(); // 清空容器v
v.insert(迭代器,x); // 向容器v中迭代器指向的位置插入x，时间复杂度O(N)
v.erase(迭代器); // 删除容器v中迭代器指向的元素，时间复杂度O(N)
v.erase(迭代器1,迭代器2); //删除容器v中两个迭代器范围中的所有元素，时间复杂度O(N)

set容器

集合，是一个内部自动有序且不含重复元素的容器。
使用时需要引用头文件:#include <set>
定义：

set<数据类型> 变量名;
// 如
set<int> s;

访问元素：
只能通过迭代器访问
除了vector容器和string容器外都不支持 *(it + i)的访问方式，只能按如下方式遍历:

for(set<int>::iterator it = s.begin(); it != s.end(); it++){
	cout<<*it<<" ";
}
// 若set容器s中有{0,1,6,8}，则该代码会输出0 1 6 8

常用函数：

s.insert(x); // 将元素x插入容器s中，并自动排序和去重，时间复杂度O(logN)
s.find(x); // 查找元素x在容器s中的位置，并返回迭代器，时间复杂度O(logN)
s.erase(迭代器); // 删除容器s中迭代器指向的元素，时间复杂度O(1)，可以结合find()使用
s.erase(迭代器1,迭代器2); //删除容器s中两个迭代器范围中的所有元素，时间复杂度O(N)
s.size(); // 返回值为容器s的元素个数，时间复杂度O(1)
s.clear(); // 清空容器s，时间复杂度O(N)

map容器

map容器是一种关联容器，它允许快速的键值查找和插入操作。map容器通过键（key）来存储和访问元素，使得查找和插入操作的时间复杂度为O(logN)。在map容器中，键是唯一的，每个键只能对应一个值。
使用时需要引用头文件:#include <map>
定义：

map<数据类型,数据类型> 变量名;
// 如
map<int> m;

访问容器中的元素：
1.通过下标访问，和数组一样，不过下标为键，即通过键访问对应的值
2.通过迭代器访问

map<数据类型,数据类型>::iterator 迭代器名;
迭代器->first; // 访问键
迭代器->second; // 访问值

常用函数：

m.find(键); // 返回对应该键的迭代器，若键不存在则返回m.end()，时间复杂度O(logN)
m.size(); // 返回值为容器中映射的对数
m.clear(); // 清空容器，时间复杂度O(N)
m.erase(迭代器); // 删除容器中迭代器指向的映射对，时间复杂度O(1)
m.erase(键); // 删除容器中键对应的映射对，时间复杂度O(logN)
m.erase(迭代器1,迭代器2); //删除容器中两个迭代器范围中的所有元素，时间复杂度O(N)

queue容器

一个先进先出的容器，即队列
使用时需要引用头文件:#include <queue>
定义：

queue<数据类型> 变量名;
// 如
queue<int> q;

访问容器中的元素：
由于队列是一种先进先出的限制性数据结构，因此只能通过front()和back()来访问队首和队尾元素

q.front(); // 返回队首元素
q.back(); // 返回队尾元素

常用函数：

q.push(x); // 将元素x入队尾，时间复杂度O(1)
q.pop(); // 将队首元素出队，时间复杂度O(1)
q.empty(); // 判断队列是否为空，空返回值为true，非空返回值为false
q.size(); // 返回值为队列中元素个数，时间复杂度O(1)

priority_queue优先队列

默认情况下，优先队列队首元素为最大，即：

priority_queue<int> q;
// priority_queue<int,vector<int>,less<int>> q;
q.push(6);
q.push(7);
q.push(4);
q.push(2);
while (!q.empty()) {
	cout << q.top() << " ";
	q.pop();
}
//输出为：7 6 4 2

优先队列实现队首元素最小，即：

priority_queue<int,vector<int>,greater<int>> q;
q.push(6);
q.push(7);
q.push(4);
q.push(2);
while (!q.empty()) {
	cout << q.top() << " ";
	q.pop();
}
//输出为：2 4 6 7

stack容器

一个后进先出的容器，即栈
使用时需要引用头文件:#include <stack>
定义：

stack<数据类型> 变量名;
// 如
stack<int> s;

访问元素：
由于栈是一种后进先出的限制性数据结构，因此只能通过top()来访问栈顶元素

s.top(); // 返回值为栈顶的元素

常用函数：

s.push(x); // 将元素x入栈顶，时间复杂度O(1)
s.pop(); // 将栈顶元素出栈，时间复杂度O(1)
s.empty(); // 判断栈是否为空，空返回值为true，非空返回值为false
s.size(); // 返回值为栈中元素个数，时间复杂度O(1)

dueue容器

双向队列
使用时需要引用头文件:#include <dueue>
定义：

dueue<数据类型> 变量名;
// 如
dueue<int> d;

常用函数：

d.begin(); // 开始的迭代器
d.end(); // 结束的迭代器
d.rbegin(); // 反向开始的迭代器
d.rend();	// 反向结束的迭代器
d.size();	// 所含元素个数
d.max_size(); // 最大能容纳的元素个数
d.resize(); // 重新调整其大小
d.empty(); // 判断其是否是空的
d.front();// 最前面的元素
d.back();	// 最后面的元素
d.assign(); // 可用它通过数组来对其进行赋值
d.push_back(); // 在双端队列后面添加元素
d.push_front(); // 在双端队列前面添加元素
d.pop_back();	// 弹出双端队列最后一个元素
d.pop_front(); // 弹出双端队列最前面一个元素