STL中data structure使用方法总结
vector
构造方法：
int x[]={1,2,3};
vector a(10,4); // 10个4
vector b(x,x+3); // 数组
vector c(a.begin(),a.end()); // 迭代器
vector d(a); // 拷贝构造
vector e({1,2,3}); // initializer_list构造 迭代器：
for(auto it=d.begin();it!=d.end();++it); // 正向遍历
for(auto it=d.rbegin();it!=d.rend();++it); // 反向遍历
cbegin, cend, crbegin, credn // 常量迭代器，c++11常用函数：
size() // 元素个数
max_size() // 最多元素个数
capacity() // 发生realloc前能允许的最大元素个数，即预分配的内存空间
clear() // 清除vector
empty() // vector是否为空
resize(n) // 当n小于等于当前vector的size时，取前n个，否则增加元素(数值类型: 0)
resize(n, val) // 当n小于等于当前vector的size时，取前n个，否则增加元素val
reserve(n) // 当n大于当前vector的size时，capacity变为n，否则什么也不做
[]或者at() // 用于索引
front() // 返回第一个元素的引用
back() // 返回最后一个元素的引用
data() // c++11, 返回vector内部使用内存的首地址(第一个元素的首地址)
assign(n, val) // n个val
assign(x, x+3) // 数组
assign(start, end) //迭代器
push_back(val) // 末尾增加一个val
pop_back() // 删除最后一个元素
insert(it, n, val) // 在迭代器it位置插入n个val
insert(it, x, x+3) // 在迭代器it位置插入数组x[0,1,2]
insert(it, start, end) // 在迭代器it位置插入迭代器所指区间[start,end)
erase(it) // 删除迭代器it对应的元素
erase(start, end) // 删除迭代器区间[start, end)
swap(d) // 与vector d交换
emplace // 类似insert, 参数形式Args&&... args
emplace_back // 类似push_back, 参数形式Args&&... argsset
构造方法：
set a{20,3,50}; // initializer_list构造
set b(x,x+3); // 数组
set c(b.begin(),b.end()); // 迭代器
set d(a); // 拷贝构造
set > e(x,x+3); // greater为降序排列
set f; // 默认构造 迭代器：
与vector类似，但是不支持+/-，只支持++/--
常用函数：
size() // 元素个数
max_size() // 最多能容纳的元素个数
empty() // 是否为空
clear() // 清除元素
pair insert(value) // 返回插入的位置iterator和是否插入成功
iterator insert(it, value) // 从it开始搜索插入value，返回插入的位置
insert(begin, end) // 将区间[begin, end)里的元素逐一插入
emplace(Args&&... args) // c++11的insert
emplace_hint(it, Args&&... args) // c++11的insert
void erase(it++) // 删除迭代器it，使用后置自增技术，自增后的it为删除元素的下一个位置
iterator erase(it) // c++11返回删除元素的下一个位置
void erase(begin, end) // 删除区间[begin, end)，线性复杂度
iterator erase(begin, end) // c++11返回end
erase(value) // 删除元素value, 返回删除的元素个数
find(value) // 返回value对应的迭代器，若不存在value，则返回end
count(value) // 返回value的个数
swap(set) // 两个set交换
key_comp()(element, value) // key_comp()为函数对象，定义了偏序关系'<'，若element equal_range(value) // 返回value的区间，begin=lower_bound(value), end=upper_bound(value) map
构造方法：
pair pa[3]={{"bb",3},{"aa",5},{"cc",4}};
map a; // 默认构造，默认升序
map b(pa, pa+3); // pair数组
map c(b.begin(), b.end()); // 迭代器区间
map d(b); // 拷贝构造
map > e(pa, pa+3); // key降序排列 迭代器：
for(auto it=d.begin();it!=d.end();++it); // 正向遍历
for(auto it=d.rbegin();it!=d.rend();++it); // 反向遍历
与set的不同之处是，这里的it是pair指针
cbegin, cend, crbegin, credn // 常量迭代器，c++11
常用函数：
size() // 元素个数
max_size() // 最多能容纳的元素个数
empty() // 是否为空
clear() // 清除元素
[key] // 返回key对应的value，若不存在key，则用默认构造函数插入这个key，map的size会增加1
at(key) // 返回key对应的value，若不存在key，则报错
find(key) // 查找key返回对应的迭代器，若不存在key，返回end
count(key) // 返回key的个数
swap(map) // 交换两个map
lower_bound(key) // 类似set
upper_bound(key) // 类似set
equal_range(key) // 类似set
pair insert(pair) // 返回值iterator指向pair.first的位置, 若pair.first原本就存在，插入失败，bool=false，反之bool=true
iterator insert(it, pair) // 返回iterator指向插入pair.first的位置
insert(begin, end) // 将区间[begin, end)里的元素逐一插入
void erase(it++) // 删除迭代器it，使用后置自增技术，自增后的it为删除元素的下一个位置
iterator erase(it) // c++11返回删除元素的下一个位置
void erase(begin, end) // 删除区间[begin, end)，线性复杂度
iterator erase(begin, end) // c++11返回end
erase(key) // 删除元素key, 返回删除的元素个数
string
构造方法：
string a; // 默认
string b("hello"); // C字符串
string c("hello", 2); // C字符串的前2个字符
string d(b, 1, 2); // b的下标从1开始长度为2的子串，不加长度默认到末尾
string e(4, 'x'); // 4个'x'
string f(b.begin(), b.end()); // 迭代器
string g({'h','e','l','l','o'}); // initializer_list构造常用函数：
size() // 字节数
length() // 同size()
max_size() // 最大能容纳的字节数
capacity() // 同vector，一般采用倍增方式分配空间
resize() // 同vector
reserve() // 同vector
clear() // 清空string
empty() // 是否为空串
[],at(),back(),front() // 同vector
+= C-string/string/char // 追加字符(串)
append(str) // string
append(str, start, len) // string从start开始长度为n的子串
append(cstr) // c-string
append(cstr, n) // c-string的前n个字符
append(n, char) // n个char
append(begin, end) // [start, end)
append(initializer_list) // {char, ...}
push_back(char) // 追加字符char
string很多函数的参数都和append的参数类似，以下就用...表示，基本上分为：
1. string
2. string的子串[start, start+len)
3. c-string
4. c-string的长度为n的前缀
5. n个字符char
6. 区间[begin, end)，数组，迭代器均可
7. initializer_list类型, c++11
assign(...) // 字符串赋值
string& insert(pos, ...) // 在下标pos位置处插入(去除情况6和7)
iterator insert(it, char) // 在迭代器it位置处插入字符，返回插入位置的迭代器
string& erase(start, len) // 删除下标区间[start, start+len)
iterator erase(it) // 删除迭代器it位置的字符，返回下一个位置的迭代器，实际上删除后it就变为了下一个位置的迭代器
iterator erase(begin, end) // 删除迭代器区间[start, end)，返回下一个位置的迭代器
replace(start, len, ...) // 替换[start, start+len)为...(去除情况6和7)
replace(start, end, ...) // 替换[start, end)为...(去除情况2)
swap(string) // 两个字符串交换
pop_back() // 长度减1，c++11
getline(stream, str &) // 从stream里提取字符串直到'\n'，放入str，提取的字符串从stream里丢弃，'\n'也被丢弃但没有放入str
getline(stream, str &, char) // 从stream里提取字符串直到char，放入str，提取的字符串从stream里丢弃，char也被丢弃但没有放入str字符串的操作：
const char* c_str() // 返回c-string常量，如果想要修改，使用strcpy把返回值拷贝给变量字符串数组
data() // 和c_str()一样
copy(char *s, len, start) // 将子串[start,start+len)拷贝到s，返回长度len，注意手动在s末尾加上'\0'
string::npos // unsigned int最大值4294967295，二进制全1
find(str, pos=0) // 返回从pos开始找第一次出现str的位置，若不存在，返回npos
find(cstr, pos=0) // 查找cstr
find(cstr, pos, len) // 查找cstr的长度为len的前缀
find(char, pos=0) // 查找字符char
注意： string的find采用了brute force的算法，并非KMP
rfind(str, pos=npos) // 返回最后一次出现str的位置，若不存在，返回npos，最后一次出现str的位置要小于等于pos，其他参数版本类似find
find_first_of(str, pos=0) // 与find不同，任何属于str的字符都算出现一次
find_last_of(str, pos=npos) // 与rfind不同，任何属于str的字符都算出现一次
find_first_not_of(str, pos=0) // 任何不属于str的字符都算出现一次
find_last_not_of(str, pos=npos) // 任何不属于str的字符都算出现一次
substr(pos, len=npos) // 返回子串[pos,pos+len)，默认长度(npos)到末尾
compare(str) // 与str相等返回0，大于str返回>0，否则返回<0
compare(cstr) // 与cstr比较
compare(start, len, ...) // [start, start+len)与...比较(...这里主要是1~4情况)字符串split的实现：
vector split(const string &str,const char *delim){
char *mem=new char[str.size()+1];
strcpy(mem,str.c_str());
vector tokens;
char *token=strtok(mem,delim);
while(token){
tokens.push_back(token);
token=strtok(NULL,delim);
}
delete [] mem;
return tokens;
} 这里利用库函数strtok来实现split的功能，注意这里的split不同于其他语言的split，例如python的split(";a", ";")可能分割出空串，而这个函数不会
queue
构造方法：
queue a; // 空队列，默认底层容器是deque
queue > b(deque); // 使用deque来初始化
queue > c(list); // 使用list来初始化
queue > d(vector); // 使用vector来初始化 常用函数：
empty() // 队列是否为空
size() // 队列里元素个数
front() // 队首元素(引用)
back() // 队尾元素(引用)
push() // 队尾入队
pop() // 队首出队
swap(queue) // 交换两个队列priority_queue
构造方法：
priority_queue a; // 空的优先队列，默认底层容器是vector，大顶堆
priority_queue > b(vector); // 使用vector初始化
priority_queue > c(deque); // 使用deque初始化
priority_queue, greater > d; // 小顶堆
priority_queue e(x, x+3); // 数组 常用函数：
empty() // 优先队列是否为空
size() // 优先队列里元素个数
top() // 堆顶元素(常量引用)
push() // 入堆
pop() // 出堆
swap(priority_queue) // 交换两个优先队列stack
构造方法：
stack a; // 空的栈，默认底层容器为deque
stack > b(deque); // 使用deque初始化
stack > c(list); // 使用list初始化
stack > d(vector); // 使用vector初始化
常用函数：
empty() // 栈是否为空
size() // 栈里元素个数
top() // 栈顶元素(引用)
push() // 入栈
pop() // 出栈
swap(stack) // 交换两个栈待更新...