STL

常用STL及其函数

list

链表：双链表 不常用

assign() 给list赋值 
back() 返回最后一个元素 
begin() 返回指向第一个元素的迭代器 
clear() 删除所有元素 
empty() 如果list是空的则返回true 
end() 返回末尾的迭代器 
erase() 删除一个元素 
front() 返回第一个元素 
get_allocator() 返回list的配置器 
insert() 插入一个元素到list中 
max_size() 返回list能容纳的最大元素数量 
merge() 合并两个list 
pop_back() 删除最后一个元素 
pop_front() 删除第一个元素 
push_back() 在list的末尾添加一个元素 
push_front() 在list的头部添加一个元素 
rbegin() 返回指向第一个元素的逆向迭代器 
remove() 从list删除元素 
remove_if() 按指定条件删除元素 
rend() 指向list末尾的逆向迭代器 
resize() 改变list的大小 
reverse() 把list的元素倒转 
size() 返回list中的元素个数 
sort() 给list排序 
splice() 合并两个list 
swap() 交换两个list 
unique() 删除list中重复的元素

转自

vector

vector为变长数组，每次倍增

基本用法

#include <vector>//头文件
int array[10];
vector<int> a(10);
vector<int> b(10,1);
vector<int> c(b);
int n;
vector<int> d(b.begin(),b.begin()+n);
vector<int> e(array);
vector<int> f(array,array+n);
vector<int> vi;
auto i = vi.begin();//迭代器
int n;
i+=n;//支持++，--，+=，-=
vi == a;//可以用比较运算符按“字典序”比较
vi.size();//获取数字大小
vi.empty();//是否为空，空则返回true，非空则返回false
vi.clear();//清空
vi.front()//返回头的引用
vi.back();//获取尾的引用
vi.begin();//返回头的迭代器
vi.end();//返回尾的迭代器
vi.push_back()//尾部添加元素
vi.pop_back();//尾部删除元素
vi.assign(b.begin(),b.begin()+3);//将复制b的前三个元素
vi.assign(4,2);//前4个元素赋值为2
vi[i];//第i个元素，只能获取已存在的元素
a.erase(a.begin(),a.begin()+3);//删除从a.begin()算起一直到a.begin()+3（不包括它）结束
a.insert(a.begin(),5);//在a.begin()位置插入数值5,
a.insert(a.begin(),3,5);//在a.insert(a.begin(),3,5);位置插入3个数，其值都为5
a.insert(a.begin(),array+3,array+6);//a.begin()的位置插入array的第三个元素到第5个元素（不包括array+6）
a.capacity();//返回a在内存中总共可以容纳的元素个数
a.resize(10);//将a的现有元素个数调整至10个，多则删，少则补，其值随机
a.resize(10,2);//将a的现有元素个数调整至10个，多则删，少则补，其值为2
a.reserve(100);//将a的容量扩充至100，
a.swap(b);//b为向量，将a中的元素和b中的元素整体交换

二维vector

vector<vector<int>> v(10,vector<int>(10,0)); //初始化
//有些编译器版本需要把“>>”分开写“> >”
v.resize(n, vector<int>(m，0));//重置

常用算法

#include <algorithm>//头文件
sort(a.begin(),a.end());//对a中从a.begin()到a.end()（不包括它）的元素进行从小到大排列
reverse(a.begin(),a.end());//对a中从a.begin()到a.end()（不包括它）的元素倒置
copy(a.begin(),a.end(),b.begin()+1);//把a中从a.begin()到a.end()（不包括它）的元素复制到b中
find(a.begin(),a.end(),10);//在a中从a.begin()到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置
unique(a.begin(),a.end());
nth_element(a.begin(),a.begin()-k+1,a.end())

pair

相当于两元素的结构体；

#include <iostream>//似乎是封装在这
pair<int,int> p;//支持比较，以first为第一关键字，second为第二关键字
pair<int,pair<int,int>> pp;//可以嵌套
p.first;//第一个元素
p.second;//第二个元素

string

字符串

#include <string>//头文件
string s;//支持通过+链接字符/字符串
s.substr(1,2);//从下表1开始长度为2的字串；过大不填充，第二参数可以省略
s.c_str();//返回a的首指针供printf输出
s.size();
s.length();
s.empty();
s.clear();

queue

队列

#include <queue>
queue<int> q;
q.size();
q.empty();
q.push();//向队头插入元素
q.front();//返回对头的引用
q.back();//返回队尾的引用
q.pop();//弹出队头
q = queue<int>();//清空队列

priority_queue

优先队列，原理堆

#include <queue>
priority_queue<int> bheap;//大根堆
bheap.size();
bheap.empty();
bheap.push();//插入元素
bheap.pop();//删除堆顶元素
bheap.top();//返回堆顶元素
//小根堆方法
//	1 插入它的负数，取出来再还原
//  2 直接定义
//
priority_queue<int,vector<>,greater<int>> sheap;

stack

栈

#include <stack>
stack<int> s;//大根堆
s.size();
s.empty();
s.push();//栈顶插入元素
s.pop();//弹出栈顶元素
s.top();//返回栈顶元素

deque

双端队列:加强版的vector
速度相对慢

#include <deque>
deque<int> dq;
dq.size();
dq.empty();
dq.clear();
dq.front()//返回头的引用
dq.back();//获取尾的引用
dq.begin();//返回头的迭代器
dq.end();//返回尾的迭代器
dq.push_back()//尾部添加元素
dq.pop_back();//尾部删除元素
dq.push_front()//头部添加元素
dq.pop_front();//头部删除元素
dq[i];

set/map

基于平衡二叉树（红黑树），动态维护有序列表

set/multiset

#include <set>
set<int> s;//忽略重复元素
multiset<int> ms;
s.size();
s.empty();
s.clear();
s.begin();
s.end();//支持 ++，-- O(logn)
int x;
s.insert(x);//插入一个数x O(logn)
s.find(x);//查找元素，返回x的迭代器 O(logn)，不存在返回s.end()
s.count();//数x的个数O(logn)
s.erase();
	//(1)参数：数  	　	删除所有等于这个数的节点O(k+logn)
	//(2)参数：迭代器　	删除迭代器
s.lower_bound(x);//返回大于等于x的最小数的迭代器,不存在返回s.end()
s.upper_bound(x);//返回大于x的最小数的迭代器,不存在返回s.end()

map

#include <map>
map<int,int> m;
multimap<int,int> mm;
m.size();
m.empty();
m.clear();
m.begin();
m.end();//支持 ++，--
int x;
m[x]++;//初始为0，时间复杂度为O(logn),multi不支持
m.insert();//插入一个数pair
m.find();
m.erase();//迭代器或pair
s.lower_bound();//返回大于等于x的最小数的迭代器,不存在返回s.end()
s.upper_bound();//返回大于x的最小数的迭代器,不存在返回s.end()

哈希表

unordered_set/unordered_multiset/unordered_map/unordered_multimap
增删改查时间复杂度O(1)，不支持lower_bound()/upper_bound(),++,–；

#include <unordered_set>//c++11
#include <unordered_map>//c++11

bitset

压位，减少空间消耗

#include <bitset>
const int N = 10;
bitset<N> a(b);//N必须是已知的常量
char cs = "0010100";
string s = "011";
bitset<N> c(cs);
bitset<N> d(s);
cs[0];//0位最低位
c == d //支持位运算和逻辑运算
a.count();//返回有多少个1
a.any();//是否有1
a.none();//是否全为零
a.set();//把所有位置置1
a.set(k,v);//把第k位变成v
a.reset();//所有位置0
a.flip();//<=> ~
a.flip(k);//把第k位取反