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
 

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)
    cout<<*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)
    cout<<*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)
    cout<<*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 開始）