STL

string

#include<cstring>
string s1,s2;

s1 + s2;    // 将两个字符串拼接
[cur];      // 访问下标
s1.size();  // 返回字符串长度
s1.append(s2);          // 将 s2 添加到 s1 末尾
s1.replace(pos, n, s2); // 删除从 pos 开始的 n 个字符，然后在 pos 处插入串 s
s1.erase(pos, n);       // 删除从 pos 开始的 n 个字符
s1.insert(pos, s2);     // 在 pos 位置插入字符串 s
s1.substr(start, len);  // 从 start 截取一个长度为 len 的字符串
s1.find(char，st = 0);  // 查找并返回从 start 开始的字符 ch 的位置
s1.rfind(ch);           //从末尾开始，查找并返回第一个找到的字符 ch 的位置
// 找不到则返回 -1

queue

先进先出

#include<queue>

queue<int> q; 
// priority_queue<int> q（从大到小排序）;

q.empty();      // 判断队列是否为空
q.size();       // 返回队列长度
q.push(item);   // 对于 queue，在队尾压入一个新元素
                // 对于 priority_queue，在基于优先级的适当位置插入新元素
q.pop();        // 弹出队首元素

// queue only:
q.front();      //返回队首元素的值，但不删除该元素
q.back();       //返回队尾元素的值，但不删除该元素
     
// priority_queue only:
q.top();        //返回具有最高优先级的元素值，但不删除该元素

stack

先进后出

#include<set>
stack<int> s; 
stack<int, vector<int> > stk;  // 覆盖基础容器类型，使用vector实现stk
s.empty();      // 判断 stack 是否为空，为空返回 true，否则返回 false
s.size();       // 返回 stack 中元素的个数
s.pop();        // 删除栈顶元素，但不返回其值
s.top();        // 返回栈顶元素的值，但不删除此元素
s.push(item);   // 在栈顶压入新元素 item

vector

#include <vector>
vector<int> v;

/* 操作 */
v.clear();  // 清空
v.swap(v1); // 和另一个 vector 进行交换，常数复杂度

v.push_back(k);     // 从末尾插入
v.emplace_back(k);  // 从末尾插入，更快
v.pop_back();       // 弹出末尾元素

v.insert(v.begin() + pos, k);   // 在下标为 pos 之前插入 k
v.emplace(it, k);   // 同上面的 insert，更快，但只能插入一个元素
v.insert(it, n, k); // 在 it 之前插入 n 个 k
v.insert(it, v1.begin(), v1.end()); // 在 it 之前插入另一个 vector 中的一段（左闭右开）
v.insert(it, {1, 2, 3, 4, 5});  // 显而易见
v.erase(it);        // 删除 it 指的元素，合并左右部分
v.erase(it, it2);   // 删除 [it, it2) 的元素，合并左右部分

/* 查询 */
v[k];       // 访问第 k 个元素
v.front();  // 返回首元素
v.back();   // 返回尾元素
v.begin();  // 返回首元素的迭代器
v.end();    // 返回数组尾端占位符的迭代器（空）
v.empty();  // 返回 vector 是否为空
v.size();   // 返回 vector 元素个数

/* 遍历 */
for(int i = 0; i < v.size(); ++i)
    v[i];

list

链表

#include <list>
list<ll> l, l2;
list<ll>::iterator it;

/* 操作 */
l.clear();      // 清空
l.insert(it, 0);// 在迭代器前面插入一个元素，迭代器指向原来的元素
l.erase(it);    // 删除迭代器指向的元素
l.remove(0);    // 在 list 删除某一种元素（全删）
l.push_back(0); // 在 list 的末尾添加一个元素   
l.push_front(0);// 在 list 的头部添加一个元素 
l.pop_back();   // 删除最后一个元素 
l.pop_front();  // 删除第一个元素 
l.merge(l2);    // 合并两个 list 
l.reverse();    // 把 list 的元素倒转 
l.sort();       // 给 list 排序 
l.swap(l2);     // 交换两个 list 
l.unique();     // 删除 list 中重复的元素

/* 查询 */
l.begin();      // 返回指向第一个元素的迭代器 
l.end();        // 返回末尾的迭代器 
l.front();      // 返回第一个元素 
l.back();       // 返回最后一个元素 
l.empty();      // 如果 list 是空的则返回 1
l.size();       // 返回 list 中的元素个数 

/* 遍历 */
for(it = l.begin(); it != l.end(); ++it)
    *it;

set

自动从小到大排序，自动去重。

set<int> s;
// multiset<int> s （不去重）
set<int>::const_iterator iter; // 迭代器 

s.insert();   // 插入
s.erase();    // 若参数为元素值，则删除所有该元素值
              // 若参数为迭代器，则删除该迭代器指向的值
s.empty();    // 判断 set 是否为空，为空返回 true，否则返回 false
s.count();    // 返回某个值元素的个数
s.clear();    // 清除所有元素
s.find();     // 查找某元素，找到则返回其迭代器，否则返回 s.end()
s.begin();    // 返回指向第一个元素的迭代器
--s.end();    // 返回指向最后一个元素的迭代器
*s.begin();   // 返回指向第一个元素的值
*--s.end();   // 返回指向最后一个元素的值
              // 区间形式为 [ begin , end ) ，所以 end 要自减
s.size();     // 返回集合中元素的个数
*s.lower_bound(k);    // 返回第一个大于等于k的元素值
*s.upper_bound(k);    // 返回第一个大于k的元素值 （后继）
              // 如果没有符合条件的值，则输出 s.size()

/* 遍历 */
for(iter = s.begin() ; iter != s.end() ; ++iter)
    *iter; // 使用迭代器遍历 

unordered_set

不排序，\(O(1)\) 查找。

#include <unordered_set>
// #include <unordered_multiset>
unordered_set<ll> s;
// unordered_multiser<ll> s;

s.insert(); // 在开头插入某元素
s.find();   // 查找，返回迭代器
s.count();  // 返回某个值元素的个数

/* 遍历 */
for(iter = s.begin() ; iter != s.end() ; ++iter)
    *iter; 
// 注意：新插入的元素遍历时先被扫到。

map

#include<map>
map<string, int> m;// string 是 key，int 是 value。

/* 基本操作 */
m.size();   // 输出元素个数
m.empty();  // 如果 map 为空则返回 true
m.clear();  // 删除所有元素

/* 插入 */
m["AKIOI"] = 10;
m.insert(make_pair("AKIOI", 10));

/* 修改 */
m["AKIOI"] = 10;
m.find("AKIOI")->second = ...;

/* 查找 */
m["AKIOI"];
m.find("AKIOI")->second;

/* 遍历 */
它会按照 key 排序
for(auto it = mp.begin(); it != mp.end(); ++it) 
    cout << it->second << ' ';

multimap

#include <map>
multimap<int, string> mp; // 可重

mp.size(), mp.empty(), mp.clear(); // 常规操作
mp.count(k) // 找 key 为 k 的个数
mp.find(k)  // 返回第一个插入的 k 的迭代器
mp.erase(k) // 删除所有键值为 k 的元素

/* 插入 */
mp.insert(make_pair(int, string)); // 只能用 make_pair 构造键值对

/* 修改 */
m.find(k)->second = ...; // 修改第一个插入的 key 为 k 的
for(auto it = mp.find(k); it->first == k; ++it) // 修改 key 为 k，值为自己选的
    if(it->second == "I") it->second = "Love"; 

/* 查找 */
mp.find(k)->second;

/* 遍历 */
for(auto it = mp.begin(); it != mp.end(); ++it) 
    cout << it->second << ' ';

unordered_map

#include<unordered_map>
用法：与 map 差别不大。
优点：因为内部实现了哈希表，因此其查找速度非常的快
缺点：哈希表的建立比较耗费时间
适用处：对于查找问题，unordered_map会更加高效一些，因此遇到查找问题，常会考虑一下用 unordered_map

bitset

bitset<100> b;
bitset<100> f;

b = 10, f = 11;
b[0]; // 访问某一位

/* 相同大小的 bitset 可以进行运算符操作 */
/* == != & &= | |= ^ ^= ~ << <<= >> >>=  */

b.count();  // 返回 1 的数量
b.size();   // 返回 bitset 的大小
b.any();    // 若有 1， 返回 1
b.none();   // 若无 1， 返回 1
b.all();    // 若全是 1， 返回 1
b.set();    // 全部设为 1
b.set(0, 0);// 将第 pos 位设为 k
b.reset();  // 全部设为 0
b.flip();   // 翻转每一位
b.flip(0);  // 翻转某一位

rope

rope 的复制操作是 \(O(\log n)\) 的，可以较轻松地实现可持久化。

想要使用 rope，需要在头文件中加入两行：

#include <ext/rope>
using namespace __gnu_cxx;

定义字符串类型的 rope，叫做 crope，要这样定义：

crope a;

支持的操作：

a.push_back(x);  // 在 a 的末尾添加字符串 x
a.insert(k, x);  // 在 a 的第 k 个字符后加入字符串 x
a.erase(k, x);   // 在 a 的第 k 个字符后删除 x 个字符
a.replace(k, x); // 将 a 的第 k 个字符后 x 的长度个字符删除，并插入 x
a.substr(k, x);  // 获取 a 的第 k 个字符后的长度为 x 的字符串
a.at(k);         // 获取 a 的第 k 个字符（从 0 开始）