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，start=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

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<<" ";//使用迭代器遍历 
}

map

#include<map>
map<string,int> m;//string 是 key，int 是 value。
m.size();   //输出元素个数
m.empty();  //如果 map 为空则返回 true
m.clear();  //删除所有元素
......

m["AKIOI"] = 10;
cout << m["AKIOI"];
输出结果：10

unordered

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

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 开始）