目录
http://www.cplusplus.com/reference/
2. deque（一个中央控制器和多个缓冲区，支持随机访问，两端快速增删）
4. 适配器（对容器的再封装）：stack、queue（底层存储结构为list 或 deque）
5.set（红黑树，有序，不重复）multiset（可重复）
unordered_set (无序，查找O(1)) unordered_multiset(无序，查找O(1),可重复)
6.map（红黑树，有序，不重复）multimap（可重复）
unordered_map (无序，查找O(1)) unordered_multimap(无序，查找O(1),可重复)
http://www.cplusplus.com/reference/
C++ STL ：
STL（标准模板库 Standard Template Library, STL）提供的高效算法来管理数据。为应对多种需求，STL为用户提供了多种名为容器（Container）的类，用于管理数据集合。在创建动态数组、表、栈、队列等数据结构时，我们只需要定义对应的容器，然后调用相应成员函数或算法即可。
所有 size()方法 返回类型为 无符号整数 做减法时要注意，为避免可以 先赋值 给 符号 int
1. list（双向链表，两端快速增删）
就是一个双向链表
- 高效率支持任意位置删除插入元素，不需移动内存
- 不能随机访问，可直接访问两端元素
- 没有空间预留，每分配一个元素，分配内存
2. deque（一个中央控制器和多个缓冲区，支持随机访问，两端快速增删）
是一个双端队列，在堆中保存内容，保存形式如下：
堆1 -> 堆2 -> 堆3 ---
每个堆保存几个元素，堆之间有指针指向，像是list 和 vector 的结合品
- 高效支持两端插入删除
- 有保留空间，但不要求连续空间，可保存元素比vector更大
- 随机访问不如vector，需要内部处理堆跳转
3. vector(数组，支持随机访问)
就是一个动态数组
- 对中间和开始处 添加删除元素 需要移动内存；对末尾元素操作最快
- 如果元素是结构或类，移动时还会进行构造和析构，故最好存放结构或类的指针
- 堆中分配一段连续内存空间，减少元素后也不会释放内存，故会有保留空间
- 当新值大于当前空间时才会重新申请一块足够大的内存并进行内存拷贝，大大影响效率
| 函数 | 操作 |
|
| v.size() | 返回元素个数, unsigned int, 直接做减法时注意 |
|
| v.pop_back() | 删除末尾元素 |
|
| v.push_back(x) | 末尾添加元素 |
|
| v.empty() | 判断是否为空 |
|
| v.begin( ) | 指向v的第一个元素地址 |
|
| v.end( ) | 指向v的最后一个元素的下一位置地址 |
|
| v.back() | 返回末尾元素，即 v[v.size()-1] |
|
| v.insert(iterator it, value) v.insert(iterator it, n, value) v.insert(iterator it, const_iterator first, const_iterator last); | 在迭代器前插入 value(value要和ｖ的元素类型相同) 在迭代器前插入 n 个value 在迭代器 it 前插入处于两个迭代器之间的一段值(迭代器指向的元素要和ｖ的元素类型相同) |
|
| v.erase(pointer1, pointer2) | 删除pointer1 到 pointer2 中间（包含pointer1所指）的元素 |
|
必须是已存在的元素,才能用下标操作符进行索引
#include<vector>
//vector 定义、初始化
//一维vector
vector<type> nums(int size);
vector<type> nums(int size, type value);
vector<type> nums{value1, value2...};
// 二维vector，设置shape[row,col]
vector<vector<int>> vec(row);
for (i = 0; i < vec.size(); i++)
vec[i].resize(col);
//或者直接定义维度，并初始化全num
vector<vector<int>> vec(row, vector<int>(col, num));4. 适配器（对容器的再封装）：stack、queue（底层存储结构为list 或 deque）
stack 栈
| 函数名 | 功能 | 复杂度 |
| size() | 返回 栈的元素数 | O(1) |
| top() | 返回 栈顶的元素 | O(1) |
| pop() | 删除栈顶元素 | O(1) |
| push(x) | 向栈中添加元素x | O(1) |
| empty() | 栈空返回true，否则false | O(1) |
queue 队列
#include<queue>
队头&队尾：插入一端称为队尾，删除一端称为队首。
| 函数名 | 功能 | 复杂度 |
| q.size() | 返回 队列 元素个数 | O(1) |
| q.front() | 返回 队首 元素 | O(1) |
| q.back() | 返回 队尾 元素 | O(1) |
| q.pop() | 删除 队首 元素 | O(1) |
| q.push(x) | 向队尾 添加 元素x | O(1) |
| q.empty() | 队列为空时 返回true | O(1) |
priority_queue 优先级队列
1、priority_queue只允许访问最顶端元素(priority_queue.top)， 而queue可以访问首尾queue.front和queue.back.
2、priority_queue内部采取的最大堆的算法，每次弹出的元素都是优先级最高的元素，并且加入或弹出元素，内部元素都需要重 新调整结构排序；
3、由于需要计算优先级，所以如果不是基本数据类型，则必须重载operator
priority_queue<ListNode*, vector<ListNode*>, cmp> que;
/*priority_queue中的三个参数，后两个可省，因为有默认参数，但是如果写第三个参数，必写第二个参数*/
priority_queue<int, vector<int>, less<int> > q;//等价于默认，大顶堆；greater<int> 小顶堆
//构造方法
priority_queue(InputIterator frist, InputIterator last) /*基本数据类型使用*/
priority_queue(InputIterator frist, InputIterator last, const Compare &x)/*复杂数据类型，需要提供比较函数*/自定义优先级的三种方法：
1.重载操作符:
bool operator < (const node &a, const node &b) {
return a.value < b.value; // 按照value从大到小排列
}
priority_queue<node>q;
2.自定义比较函数模板结构:
struct cmp{
bool operator ()(const node &a, const node &b) {
return a.value>b.value;// 按照value从小到大排列
}
};
priority_queue<node, vector<node>, cmp>q;
3.定义友元操作类重载函数
struct node{
int value;
friend bool operator<(const node &a,const node &b) {
return a.value<b.value; //按value从大到小排列
}
};
priority_queue<node>q; 5.set（红黑树，有序，不重复）multiset（可重复）
unordered_set (无序，查找O(1)) unordered_multiset(无序，查找O(1),可重复)
有序不重复，存储一个实值
set.insert(vaule)的单元素版返回一个二元组（Pair）。
成员 set.insert(value).first 被设置为指向新插入元素的迭代器或指向等值的已经存在的元素的迭代器。
成员 set.insert(value).second 是一个 bool 值，如果新的元素被插入，返回 true，如果等值元素已经存在（即无新元素插入），则返回 false。
| 函数 | 操作 | 时间 |
| set.begin(),set.end() | ||
| set.clear() | ||
| set.empty() | ||
| set.count() | ||
| set.earse() | ||
| set.find(value) | 返回查找元素的迭代器 | O(log n) |
| set.insert(value) set.insert(iter, value) set.insert(iter1, iter2) | 插入元素 指定位置插入元素 插入一段元素 | O(log n) O(1) O(log n) |
| set.size() | 元素数目 |
6.map（红黑树，有序，不重复）multimap（可重复）
unordered_map (无序，查找O(1)) unordered_multimap(无序，查找O(1),可重复)
- 关联性：
- 关联容器中的元素的参考地址指的是其 Key 值，而不是他们在容器中的绝对地址；
- map multimap 有序性：
- 容器中的元素一直按照排序方式严格排序，所有插入元素都按照该顺序排列；
- 映射：
- 每个元素中，一个 Key 值与一个映射值相关。Key 值是用来标识其主要内容是映射值的元素；
- map unordered_map 唯一 Key 值：
- 容器中不存在同时拥有相同 Key 值的两个元素；
- 分配感知 (Allocator-aware)：
- map 容器使用分配器对象动态处理其存储需求。
- map[key]
- [] 获取对应 value 的值 ,当 此键值对 不存在时会插入此 key ,并初始化 value (数字为 0,字符为空) .
- 因此可以这样 插入或 更新 键值对 ：map[key] = value
- 函数 map::find 不会产生这种效果
| 函数 | 操作 | 时间 |
| m.size() | 返回大小 | |
| m.clear() | 清空元素 | |
| m.insert(pair<type,type>(key,value)) | 添加元素 | |
| m.empty() | 判断是否为空 | |
| m.erase(pointer) | 删除pointer位置的元素 | |
| m.find(key) | 查找key位置，不存在时==m.end() | ordered O(log n) unordered O(1) |
#include<map>
//定义+初始化 方式一
map<int, int> m;
m[1] = 1, m[2] = 1, m[3] = 1;
//定义+初始化 方式二
map<int, int> m{{1,1}, {2,1}, {3,1}};
map<int, int>::iterator iter;
for(iter = m.begin(); iter != m.end(); iter++) {
cout << iter->first << " : " << iter->second << endl;
}
扫一扫
269
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
