C++ STL 常用容器

一、动态数组（vector）

1. 头文件：#include<vector>

2. 变量声明：vector <int> a;

3. 移除容器中所有数据：a.clear();

4. 判断容器是否为空：a.empty();

5. 删除 pos 位置的数据：a.erase(pos);

6. 删除 [i, u) 区间的数据：a.erase(i, u);

7. 删除某个数：

auto iter = remove(a.begin(), a.end(), x); // 删除x
a.erase(iter, ans.end());

8. 传回第一个数据：a.front();

9. 在 pos 位置插入一个 elem 拷贝：a.insert(pos, elem);

10. 合并两个 vector ：a.insert(a.end(), b.begin(), b.end());

11. 删除最后一个数据：a.pop_back();

12. 在尾部加入一个数据：a.push_back(elem);

13. 重新设置该容器的大小：a.resize(num);

14. 回容器中实际数据的个数：a.size();

15. 返回指向容器第一个元素的迭代器：a.begin();

16. 返回指向容器最后一个元素的迭代器：a.end();

17. 统计 vector 中出现的 num 元素次数：count(a.begin(), a.end(), num);

18. 排序：sort(vct.begin(), vct.end(), less<int>() );

• 排序函数如下：

  名称	功能
  equal_to	相等
  not_equal_to	不相等
  less	小于
  greater	大于
  less_equal	小于等于
  greater_equal	大于等于

二、队列（queue）

1. 头文件：#include<queue>

2. 变量声明：queue <int> q;

4. 将x压入队列的末端：q.push(x);

5. 弹出队头元素：q.pop();

6. 返回队头元素：q.front();

7. 返回队尾元素：q.back();

8. 判断队空：q.empty();

9. 返回队列的长度：q.size();

三、优先队列（priority_queue）

用于自定义数据的优先级，让优先级高的排在队列前面，优先出队。

1. 头文件：#include <queue>

2. 变量声明：priority_queue <int, vector<int>, greater<int> > q;

• 注意此处的两个右括号>需要分开写，否则会被认为是>>右移符号。

3. 访问队头元素：q.top();

4. 队列是否为空：q.empty();

5. 返回队列内元素个数：q.size();

6. 插入元素到队尾 (并排序)：q.push(x);

7. 弹出队头元素：q.pop();

8. 交换内容：swap(q1, q2);

9. 定义：priority_queue<Type, Container, Functional>;

• Type：数据类型
• Container：容器类型（用数组实现的容器，如vector,deque等，不能用list，默认为vector）
• Functional：比较方式，默认是大顶堆
• 升序队列：priority_queue <int, vector<int>, greater<int> > q;
• 降序队列（默认）：priority_queue <int, vector<int>, less<int> > q;

10. 例子：

//大顶堆
priority_queue<int> a; 
//等同于 
priority_queue<int, vector<int>, less<int> > a;
//                注意空格，否则是右移运算符↑
//小顶堆
priority_queue<int, vector<int>, greater<int> > c;

11. 自定义比较级：

struct cmp {     
	operator bool ()(int x, int y)     
	{        
		return　x > y; // x小的优先级高       
		//return p[x] > p[y];
		//表示p[i]小的优先级高
	}
};
priority_queue<int, vector<int>, cmp>q;    //定义方法

12. 自定义结构体：

struct node {     
	int x, y;// y为值, x为优先级
	friend bool operator < (node a, node b)     
	{         
		return a.x > b.x;    //结构体中，x小的优先级高     
	}
};
priority_queue<node>q;   //定义方法
//通过自定义operator<操作符来比较元素中的优先级。

四、栈（stack）

1. 头文件：#include<stack>

2. 变量声明：stack <int> s;

3. 将 x 压入栈顶：s.push(x);

4. 删除栈顶的元素，但是不会返回：s.pop();

5. 返回栈顶的元素，但是不会删除：s.top();

6. 返回栈中元素的个数：s.size();

7. 检查栈是否为空：s.empty();

五、集合（set）、多元集合（multiset）、无序集合（unordered_set）

集合具有去重排序的功能，多元集合自动去重，无序集合没有自动排序

1. 头文件：#include<set>

2. 变量声明：

set <int> s;
set<int, greater<int>> M;
set<int, less<int>> M; //默认从小到大

3. 返回 set 容器第一个元素的迭代器：begin();

4. 返回 set 容器最后一个元素的迭代器：end();

5. 删除 set 容器中所有的元素：clear();

6. 判断 set 容器是否为空：empty();

7. 返回 set 容器可能包含的元素最大个数：max_size();

8. 返回当前 set 容器中的元素个数：size();

9. 判断 x 值是否存在：count(x);

• 本意为计数，但是set中不存在重复值，故结果只能为 0 或 1
• multiset中为计数

10. 删除位置在 u 到 i 之间的元素：erase(u,i);

11. 删除键值key_value的值：erase(key_value);

12. 返回第一个大于等于 key_value 的迭代器：lower_bound(key_value);

13. 返回最后一个大于等于 key_value 的迭代器：upper_bound(key_value);

14. 插入值为 key_value 的元素：insert(key_value);

六、字典（map）、无序字典（unordered_map）

1. 头文件：#include<map>

2. 变量声明：map <string , int> mp;

3. 返回指向字典头部的迭代器：mp.begin();

4. 删除所有元素：mp.clear();

5. 返回指定元素 x 出现的次数：mp.count(s,x);

6. 判断字典是否为空：mp.empty();

7. 返回指向字典末尾的迭代器：mp.end();

8. 删除一个字典元素：mp.erase(s);

9. 查找一个元素：mp.find(s);

• 查找失败返回值为：mp.end();

10. 插入元素：mp.insert(s);

11. 返回可以容纳的最大元素个数：mp.max_size();

12. 返回字典中元素的个数：mp.size();

13. 交换两个字典元素：swap(mp1,mp2);

七、pair

1. 头文件：#include<utility>

2. 变量声明：pair <int, int> p(1, 2);

3. 生成：make_pair(1, 2);

4. 取值：p.first; p.sceond;

八、bitset

1. 头文件：#include<bitset>

2. 变量声明：

bitset<16> foo;
bitset<16> bar (0xfa2);
bitset<16> baz (string("0101111001"));

// result:
foo: 0000000000000000
bar: 0000111110100010
baz: 0000000101111001

3. 运算：支持各种位运算（与、或、异或、左移、右移等）

4. 返回大小（位数）：example.size()

5. 返回 1 的个数：example.count()

6. 返回是否有 1 ：example.any()

7. 返回是否没有 1 ：example.none

8. 全都变成 1 ：example.set()

9. 将第 n 位变成 1 ：example.set(n)

10. 将第 n 位变成 x ：example.set(n, x)

11. 全都变成 0 ：example.reset()

12. 将第 n 位变成 0 ：example.reset(n)

13. 全都取反：example.flip()

14. 将第 n 位取反：example.flip(n)

15. 转换为 unsigned long ，如果超出范围则报错：example.to_ulong()

16. 转换为 unsigned long long ，如果超出范围则报错：example.to_ullong()

17. 转换为 string ：example.to_string()