vector
概述
vector是一个封装了动态大小数组的顺序容器, 它能够存放各种类型的对象
可以简单的认为, vector是一个能够存放任意类型的动态数组
使用时需要头文件 #include<vector>
初始化
| 声明形式 | 时间复杂度 | 作用 |
|---|
| vector<Elem> a | O(1) | 构造一个空的 vector |
| vector<Elem> a(b) | O(n) | 拷贝构造 vector |
| vector<Elem> a(n, x) | O(n) | 构造一个含有 n 个元素 x 的 vector |
| vector<Elem> a(b.begin(), b.end()) | O(n) | 使用迭代器范围构造 |
成员函数
| 函数名 | 时间复杂度 | 作用 |
|---|
| begin() | O(1) | 返回第一个元素的迭代器 |
| end() | O(1) | 返回最后一个元素的迭代器 |
| push_back(x) | O(1) | 向容器尾部添加一个元素 x |
| pop_back() | O(1) | 删除容器尾部元素 |
| size() | O(1) | 返回容器中元素数量 |
| insert(pos, x) | O(n) | 在 pos 位置插入一个元素 x |
| erase(pos) | O(n) | 删除位置 pos 的元素 |
| erase(pos1, pos2) | O(n) | 删除位置 pos1 到 pos2 的元素 |
| clear() | O(n) | 清空容器 |
stack
概述
stack翻译为栈, 是STL中实现的一个后进先出的数据结构
使用时需要头文件 #include<stack>
初始化
| 声明形式 | 时间复杂度 | 作用 |
|---|
| stack<Elem> a | O(1) | 构造一个空的 stack |
| stack<Elem> a(b) | O(n) | 拷贝构造 stack |
成员函数
| 函数名 | 时间复杂度 | 作用 |
|---|
| empty() | O(1) | 若栈为空, 返回 true, 否则返回 false |
| push(x) | O(1) | 插入一个元素 x 到栈顶 |
| pop() | O(1) | 栈顶元素出栈 |
| top() | O(1) | 返回栈顶元素 |
| size() | O(1) | 返回栈中元素数量 |
| clear() | O(n) | 清空栈 |
queue
概述
queue翻译为队列, 是STL中实现的一个先进先出的数据结构
使用时需要头文件 #include<queue>
初始化
| 声明形式 | 时间复杂度 | 作用 |
|---|
| queue<Elem> a | O(1) | 构造一个空的 queue |
| queue<Elem> a(b) | O(n) | 拷贝构造 queue |
成员函数
| 函数名 | 时间复杂度 | 作用 |
|---|
| empty() | O(1) | 队列若为空, 返回 true, 否则返回 false |
| push(x) | O(1) | 插入一个元素 x 到队尾 |
| pop() | O(1) | 队首元素出队 |
| front() | O(1) | 返回队首元素 |
| back() | O(1) | 返回队尾元素 |
| size() | O(1) | 返回队列中元素数量 |
| clear() | O(n) | 清空队列 |
priority_queue
概述
priority_queue翻译为优先队列, 是STL中实现的一个元素具有优先级的队列
优先级高的元素排在队列前面, 优先出队
使用时需要头文件 #include<queue>
初始化
| 声明形式 | 时间复杂度 | 作用 |
|---|
| priority_queue<Elem, Container, Functional> a | O(1) | 构造一个空的 priority_queue |
| priority_queue<Elem, Container, Functional> a(b) | O(n) | 拷贝构造 priority_queue |
| priority_queue <int, vector<int>, greater<int>> a | O(1) | 构造一个升序队列 |
| priority_queue <int, vector<int>, less<int>> a | O(1) | 构造一个降序队列 |
成员函数
| 函数名 | 时间复杂度 | 作用 |
|---|
| empty() | O(1) | 优先队列若为空, 返回 true, 否则返回 false |
| push(x) | O(log n) | 插入一个元素 x 到队尾并自动排序 |
| pop() | O(log n) | 优先级最高的元素出队 |
| top() | O(1) | 返回优先级最高的元素 |
| size() | O(1) | 返回优先队列中元素数量 |
| clear() | O(n) | 清空优先队列 |
deque
概述
deque翻译为双端队列, 是STL中实现的一个两端插入和删除的队列
deque相比queue插入与删除操作时间复杂度相同但常数更大
使用时需要头文件 #include<queue>
初始化
| 声明形式 | 时间复杂度 | 作用 |
|---|
| deque<Elem> a | O(1) | 构造一个空的 deque |
| deque<Elem> a(b) | O(n) | 拷贝构造 deque |
成员函数
| 函数名 | 时间复杂度 | 作用 |
|---|
| empty() | O(1) | 双端队列若为空, 返回 true, 否则返回 false |
| push_front(x) | O(1) | 插入一个元素 x 到队头 |
| push_back(x) | O(1) | 插入一个元素 x 到队尾 |
| pop_front() | O(1) | 队首元素出队 |
| pop_back() | O(1) | 队尾元素出队 |
| front() | O(1) | 返回队首元素 |
| back() | O(1) | 返回队尾元素 |
| size() | O(1) | 返回双端队列中元素数量 |
| clear() | O(n) | 清空双端队列 |
list
概述
list翻译为链表, 是STL中实现的一个内存不连续的数据结构
链表可以高效率的支持任意地方的插入和删除操作。
使用时需要头文件 #include<list>
初始化
| 声明形式 | 时间复杂度 | 作用 |
|---|
| list<Elem> a | O(1) | 构造一个空的 list |
| list<Elem> a(n, x) | O(n) | 构造一个含有 n 个元素 x 的 list。 |
| list<Elem> a(b) | O(n) | 拷贝构造 list |
成员函数
| 函数名 | 时间复杂度 | 作用 |
|---|
| empty() | O(1) | 链表若为空, 返回 true, 否则返回 false |
| push_front(x) | O(1) | 插入一个元素 x 到表头 |
| push_back(x) | O(1) | 插入一个元素 x 到表尾 |
| insert(it, x) | O(n) | 在迭代器 it 的位置插入元素 x |
| pop_front() | O(1) | 删除表头元素 |
| pop_back() | O(1) | 删除表尾元素 |
| erase(it) | O(n) | 删除迭代器 it 所指的元素 |
| front() | O(1) | 返回表头元素 |
| back() | O(1) | 返回表尾元素 |
| size() | O(1) | 返回链表中元素数量 |
| unique() | O(n) | 删除链表中相邻的重复元素 |
| merge() | O(n) | 升序合并两个列表的元素 |
| splice(it, x) | O(n) | 在迭代器 it 位置拼接另一个链表 x |
| clear() | O(n) | 清空链表 |
set
概述
set翻译为集合, 是STL中实现的自动按照键值排序的数据结构
set可以高效率的增删查改操作。
使用时需要头文件 #include<set>
初始化
| 声明形式 | 时间复杂度 | 作用 |
|---|
| set<Elem> a | O(1) | 构造一个空的 set |
| list<Elem> a(b) | O(n) | 拷贝构造 set |
成员函数
| 函数名 | 时间复杂度 | 作用 |
|---|
| empty() | O(1) | 集合若为空, 返回 true, 否则返回 false |
| begin() | O(1) | 返回第一个元素的迭代器 |
| end() | O(1) | 返回最后一个元素的迭代器 |
| insert(x) | O(log n) | 向集合插入元素 x |
| erase(it) | O(log n) | 删除迭代器 it 所指的元素 |
| erase(x) | O(log n) | 删除值为 x 的元素 |
| find(x) | O(log n) | 若存在值为 x 的元素, 返回该元素的迭代器, 否则返回end() |
| lower_bound(x) | O(log n) | 返回值大于等于元素 x 的第一个位置 |
| upper_bound(x) | O(log n) | 返回值大于元素 x 的第一个位置 |
| count(x) | O(log n) | 返回指定元素 x 出现的次数 |
| size() | O(1) | 返回集合中元素数量 |
| clear() | O(n) | 清空集合 |
map
概述
map是STL的一个关联容器, 自动建立key-value的一一对应关系, map内部所有的数据都是关于key有序的
使用时需要头文件 #include<map>
初始化
| 声明形式 | 时间复杂度 | 作用 |
|---|
| map<keyElem, valueElem> a | O(1) | 构造一个空的 map |
| map<keyElem, valueElem> a(b) | O(n) | 拷贝构造 map |
成员函数
| 函数名 | 时间复杂度 | 作用 |
|---|
| empty() | O(1) | map若为空, 返回 true, 否则返回 false |
| begin() | O(1) | 返回第一个元素的迭代器 |
| end() | O(1) | 返回最后一个元素的迭代器 |
| insert({key, value}) | O(log n) | 向map插入元素 {key, value} |
| erase(it) | O(log n) | 删除迭代器 it 所指的元素 |
| erase(x) | O(log n) | 删除键值为 x 的元素 |
| find(key) | O(log n) | 若存在键值为 key 的元素, 返回该元素的迭代器, 否则返回end() |
| lower_bound(key) | O(log n) | 返回键值大于等于键值 key 的第一个位置 |
| upper_bound(key) | O(log n) | 返回键值大于键值 key 的第一个位置 |
| count(key) | O(log n) | 返回指定键值 key 的 value |
| size() | O(1) | 返回map中元素数量 |
| clear() | O(n) | 清空map |
bitset
概述
bitset存储二进制数位, 一个元素只占 1 bit
bitset的大小在编译时就需要确定
使用时需要头文件 #include<bitset>
初始化
| 声明形式 | 时间复杂度 | 作用 |
|---|
| bitset<N> a | | 构造一个位数为 N , 值全为 0 的 bitset |
| bitset<N> a(x) | | 根据整数 x 构造一个位数为 N 的 bitset |
| bitset<N> a(x) | | 根据表示二进制的字符串 x 构造一个位数为 N 的 bitset |
成员函数
| 函数名 | 时间复杂度 | 作用 |
|---|
| size() | | 返回位数 |
| count() | | 返回 1 的个数 |
| any() | | 返回是否有 1 |
| none() | | 返回是否全为 0 |
| set() | | 全都变成 1 |
| set(pos) | | 将第 pos + 1 位变成 1 |
| reset() | | 全都变成 0 |
| reset(pos) | | 将第 pos + 1 位变成 0 |
| flip() | | 全都取反 |
| flip(pos) | | 将第 pos + 1 位取反 |
| to_ulong() | | 返回它转换为 unsigned long 的结果，如果超出范围则报错 |
| to_ullong() | | 返回它转换为 unsigned long long 的结果，如果超出范围则报错 |
| to_string() | | 返回它转换为 string 的结果 |
扫一扫
523
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
