C++标准库（STL）

1. vector（变长数组）

• 定义：vector<typename> name;
  注意：当typename为STL容器时，在两个>>之间加个空格，vector<vector<int> > name, 因为C++11之前编译器会把它当作移位操作。
  vector定义数组的方法：vector<typename> name[size]; 这样每个name[0]~name[size-1]都是一个vector容器，只是一维长度已经固定为size，另一维是可变的。

• vector容器元素访问：
  （1）通过下标访问；
  （2）通过迭代器访问：迭代器类似指针，通过地址利用*获取元素，name[i]和*(name.begin() + i)都是一样的。迭代器的定义：vector<typename>::iterator it.
  注意：name.begin()是取vector首元素地址，name.end()是取尾元素地址的下一个地址；
  迭代器不支持<操作，所以一般用！=
  在常用的STL容器中，只有在vector和string中才允许使用迭代器+整数的写法。

• 常用函数
  （1）v.push_back():在v后面加一个元素，时间复杂度o(1)
  （2）v.pop_back():在v后面删除一个元素，时间复杂度为o(1)
  （3）v.size():个数，时间复杂度为o(1)
  （4）v.clear():清空vector所有元素，时间复杂度为o(N),N为vector内元素个数
  （5）v.insert(it,x):向vector任意迭代器it处插入一个元素x，时间复杂度为o(N)
  （6）v.erase(it):删除迭代器为it处的元素
  v.erase(first, last):删除[first, last)内所有元素

2. set（内部自动有序 and 不含重复元素）

• 定义：set<typename> name;
  set的数组定义：set<typename> name[size];

• 元素访问：只能通过迭代器访问
  for(set<int> iterator it = s.begin(); it != s.end(); it++){printf(“%d”, *it};

• 常用函数：
  （1）s.insert(x)：将x插入s中，并自动排序和去重，时间复杂度为o(logN)
  （2）s.find(2)：返回set中对应值为2的迭代器，时间复杂度为o(logN)
  （3）s.erase(it): it为所需要删除元素的迭代器，时间复杂度为o(1)；
  s.erase(value): value为所需要删除元素的值，时间复杂度为o(logN);
  s.erase(first, last)：删除[first, last)内所有元素
  （4）s.size(): 获得元素个数，时间复杂度为o(1)
  （5）s.clear()：清空s中的所有元素，时间复杂度为o(N)

另外：unordered_set和set很像，唯一区别在于set会自行对存储的数据进行排序，而unordered_set不会排序。

3. string

• 定义：string str;
• 元素访问：
  （1）通过下标访问（输出整个字符串只能用cin和cout， 单个的字符可以用printf）
  （2）通过迭代器访问：string::iterator it;
• 常用函数
  （1）s1+=s2：将s2直接拼接到s1后面
  （2）两个string类型的可以直接用==， !=， <, <=, >, >=，比较规则是字典序
  （3）s.length()和s.size()：获取string长度
  （4）s.insert(pos, str): 在pos号位置插入字符串str
  s.insert(it, it2, it3)：it为原字符串的欲插入位置， it2和it3为待插字符串的首尾迭代器，把[it2, it3)插入到it的位置
  （5）s.erase(it)
  s.erase(first, last)
  s.erase(pos, length): pos为需要开始删除的起始位置（int），length为删除的字符个数
  （6）s.clear()
  （7）s.substr(pos, len): 返回pos号位开始的，长度为len的子串
  （8）s.find(str2): 当str2为str的子串时，返回其在s中第一次出现的位置， 如果不是就返回string::npos（是个常数，本身值为-1，但是由于是unsigned_int类型，所以可认为是其类型的最大值，用以作为find函数失配时的返回值）
  s.find(str2, pos): 从s的pos号位开始匹配str2
  （9）s.replace(pos, len, str2): 把s从pos位开始长度为len的子串替换为str2
  s.replace(it1, it2, str2): 把s的迭代器[it1, it2)范围的子串替换为str2

4. map（映射， 会自动排序， 内部是红黑树，和set一样

）

• 定义： map<typename1, typename2> mp;

• 元素访问：
  （1）通过下标访问
  （2）通过迭代器访问：
  map<typename1, typename2> :: iterator it;
  it - > first访问键， it - > second访问键值

• 常用函数
  （1）mp.find(key): 返回键为key的映射的迭代器，时间复杂度为o(logN)
  （2）mp.erase(it): it为要删除的元素的迭代器
  mp.erase(key): key为欲删除的映射的键
  mp.erase(first, last): 删除迭代器的[first, last)
  （3）mp.size(): 映射的对数
  （4）mp.clear(): 清空所有的元素

另外：unordered_map没有排序，并且通过key访问单个元素比map快

5. queue（先进先出）

• 定义：queue<typename> name;
• 元素访问：只能通过q.front()访问队首元素， 通过q.back()访问队尾元素
• 常用函数：
  （1）q.push(x)
  （2）q.front(), q.back()
  （3）q.pop()
  （4）q.empty():返回true则空，返回false则非空
  （5）q.size()
  注意：使用front()和pop()函数之前，必须用empty()判断队列是否为空

6. priority_queue（队首元素一定是优先级最高的元素）

• 定义：priority_queue<typename> name;
• 元素访问：只能通过q.top()来访问队首元素
• 常用函数：
  （1）q.push(x)
  （2）q.top()
  （3）q.pop()
  （4）q.empty()
  （5）q.size()

7. stack（后进先出）

• 定义：stack<typename> name;
• 元素访问：只能通过s.top()访问栈顶元素（最后一个）
• 常用元素：
  （1）s.push(x)
  （2）s.top()
  （3）s.pop()
  （4）s.empty()
  （5）s.size()

8. pair（可以看作内部有两个可以指定类型的元素的结构体）

• 定义：pair <typename1, typename2> name;
• 元素访问：访问结构体一样