STL中data structure使用方法总结

vector

构造方法：

int x[]={1,2,3};
vector<int> a(10,4);  // 10个4
vector<int> b(x,x+3);  // 数组
vector<int> c(a.begin(),a.end()); // 迭代器
vector<int> d(a); // 拷贝构造
vector<int> e({1,2,3});  // initializer_list<int>构造

迭代器：

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&&... args

set

构造方法：

set<int> a{20,3,50};                       // initializer_list构造
set<int> b(x,x+3);                         // 数组
set<int> c(b.begin(),b.end());             // 迭代器
set<int> d(a);                             // 拷贝构造
set<int, greater<int> > e(x,x+3);          // greater<int>为降序排列
set<int> f;                                // 默认构造

迭代器：

与vector类似，但是不支持+/-，只支持++/--

常用函数：

size()                  // 元素个数
max_size()              // 最多能容纳的元素个数
empty()                 // 是否为空
clear()                 // 清除元素


pair<iterator,bool> 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<value, 返回true
lower_bound(value)            // 返回第一个让key_comp()(element, value)为false的element的迭代器，若不存在，返回end
upper_bound(value)            // 返回第一个让key_comp()(value, element)为true的element的迭代器，若不存在，返回end
pair<begin, end> equal_range(value)  // 返回value的区间，begin=lower_bound(value), end=upper_bound(value)

map

构造方法：

pair<string, int> pa[3]={{"bb",3},{"aa",5},{"cc",4}};
map<string, int> a;                                   // 默认构造，默认升序
map<string, int> b(pa, pa+3);                         // pair数组
map<string, int> c(b.begin(), b.end());               // 迭代器区间
map<string, int> d(b);                                // 拷贝构造
map<string, int, greater<string> > 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<iterator,bool> 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<string> split(const string &str,const char *delim){
    char *mem=new char[str.size()+1];
    strcpy(mem,str.c_str());
    vector<string> 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<int> a;                           // 空队列，默认底层容器是deque
queue<int, deque<int> > b(deque);       // 使用deque来初始化
queue<int, list<int> > c(list);         // 使用list来初始化
queue<int, vector<int> > d(vector);     // 使用vector来初始化

常用函数：

empty()                // 队列是否为空
size()                 // 队列里元素个数
front()                // 队首元素(引用)
back()                 // 队尾元素(引用)
push()                 // 队尾入队
pop()                  // 队首出队
swap(queue)            // 交换两个队列

priority_queue

构造方法：

priority_queue<int> a;                               // 空的优先队列，默认底层容器是vector，大顶堆
priority_queue<int, vector<int> > b(vector);         // 使用vector初始化
priority_queue<int, deque<int> > c(deque);           // 使用deque初始化
priority_queue<int, deque<int>, greater<int> > d;    // 小顶堆
priority_queue<int> e(x, x+3);                       // 数组

常用函数：

empty()                      // 优先队列是否为空
size()                       // 优先队列里元素个数
top()                        // 堆顶元素(常量引用)
push()                       // 入堆
pop()                        // 出堆
swap(priority_queue)         // 交换两个优先队列

stack

构造方法：

stack<int> a;                         // 空的栈，默认底层容器为deque
stack<int, deque<int> > b(deque);     // 使用deque初始化
stack<int, list<int> > c(list);       // 使用list初始化
stack<int, vector<int> > d(vector);   // 使用vector初始化

常用函数：

empty()                      // 栈是否为空
size()                       // 栈里元素个数
top()                        // 栈顶元素(引用)
push()                       // 入栈
pop()                        // 出栈
swap(stack)                  // 交换两个栈

待更新...