C++常用数据结构使用总结
-
之前用C++写了几场笔试了,这里把自己查找的一些C++数据结构的方法整理一下,也方便自己之后查找使用。
这文章一半的目的是为了我自己找函数方便,并且希望能在不翻前后文的情况下找到需要的函数,所以几个数据结构之间会重复记录方法。
一、迭代器(针对容器的一种指针)
在讲C++的一些封装的数据结构之前,最好先了解一下迭代器。实际使用你可以不管迭代器,但了解一下原理可以更好的使用一些数据结构自带的方法。
迭代器可以理解成一种指针,只不过只用来针对容器来进行指针操作。
迭代器分以下几种
容器类名::iterator 迭代器名; //正向迭代器(好像要用也基本只用这个) 容器类名::const_iterator 迭代器名; //常量正向迭代器 容器类名::reverse_iterator 迭代器名; //反向迭代器 容器类名::const_reverse_iterator 迭代器名; //常量反向迭代器 //反向迭代器不常用,以下是一个遍历样例 for (vector<int>::reverse_iterator j = v.rbegin(); j != v.rend(); ++j) cout << *j << " "; return 0;
通过迭代器可以想指针一样读取它指向的元素,(*迭代器名) 就表示迭代器指向的元素。通过非常量迭代器还能修改其指向的元素。
此外,不同容器的迭代器,其功能强弱有所不同。容器的迭代器的功能强弱,决定了该容器是否支持 STL 中的某种算法。例如,排序算法需要通过随机访问迭代器来访问容器中的元素,因此有的容器就不支持排序算法。这边介绍常遇的三种
1) 正向迭代器。假设 p 是一个正向迭代器,则 p 支持以下操作:
++p
,p++
,*p
。此外,两个正向迭代器可以互相赋值,还可以用==
和!=
运算符进行比较。 2) 双向迭代器。双向迭代器具有正向迭代器的全部功能。除此之外,若 p 是一个双向迭代器,则
--p
和p--
都是有定义的。--p
使得 p 朝和++p
相反的方向移动。 3) 随机访问迭代器。随机访问迭代器具有双向迭代器的全部功能。若 p 是一个随机访问迭代器,i 是一个整型变量或常量,则 p 还支持以下操作:
-
p+=i:使得 p 往后移动 i 个元素。
-
p-=i:使得 p 往前移动 i 个元素。
-
p+i:返回 p 后面第 i 个元素的迭代器。
-
p-i:返回 p 前面第 i 个元素的迭代器。
-
p[i]:返回 p 后面第 i 个元素的引用。
下表是一些常见容器的迭代器类型
容器 迭代器功能 vector 随机访问 deque 随机访问 list 双向 set / multiset 双向 map / multimap 双向 stack 不支持迭代器 queue 不支持迭代器 priority_queue 不支持迭代器 注意事项:虽然有一些看起来方便的迭代器函数可以使用,例如把vector当成简单数组用时,利用迭代器可以完成在数组中插入删除的操作,但尽量避免这些超出原来数据结构的函数。这些函数可能实现过程并不简单,不利于你减低时间复杂度,而且在传统数据结构算法中是不涉及这些操作。如果你要在一个数组中进行插入删除,那么考虑用list或者哈希表来实现会更好。
-
-
二、vector(简单数组)[随机访问迭代器]
可以把它当做能够自动malloc内存空间的数组来使用,定义时要指定该容器存的数据类型。
1、初始化:
#include <vector> vector<T>(); //一个空的容器 vector<T>(int Size); //设置元素个数 vector<T>(int Size,T value); //设置元素个数和初值 vector<T>(v.begin(),v.end()); //复制另一个容器
2、增:
push_back(T value); //尾部加入 //迭代器 vector<T>::iterator it; insert(vector<T>::iterator it,T value);//在迭代器指向的元素前面插入 insert(vector<T>::iterator it,int n ,T value);//在迭代器指向的元素前面插入n个value insert(vector<T>::iterator it,l.begin(),l.end());//在迭代器指向的元素前面插入另一个vector的内容
3、删:
pop_back();//删除最后一个元素 clear(); //清空 //迭代器 vector<T>::iterator it; iterator erase(iterator it):删除向量中迭代器指向元素 iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
4、查:
T front(); //返回第一个元素 T back(); //返回最后一个元素 operator[int pos]; //返回pos位置的元素,下标表示,如果idx越界,不抛出异常,直接出错。 at(int pos); //返回pos位置的元素(不过一般都直接用下标表示) find(v.begin(), v.end(), key) != v.end() //遍历 for(int i = 0;i<v.size();++i){v[i];} for (auto &i : v){i;} //迭代器 vector<T>::iterator it; *it; //直接访问迭代器指向的元素 ++it; //双向迭代器特点 *(it+n); //随机迭代器特点 iterator begin(); //返回向量头指针,指向第一个元素 iterator end(); //返回向量尾指针,指向向量最后一个元素的下一个位置 //遍历 for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {tempNum = *it;} //反向遍历 for (vector<int>::reverse_iterator j = v.rbegin(); j != v.rend(); ++j) {tempNum = *it;}
5、改:
v[i] = (T)value; assign(int n,T x) //将容器全部内容改为n个x swap(vector<T>); //交换两个同类型向量的数据 //迭代器 vector<T>::iterator it; *it = (T)value; assign(v.begin(),v.end()) //容器中[first,last)中元素设置成当前向量元素
6、其他方法:
empty(); //是否为空 size(); //返回元素个数 resize(int n); //将容器的元素个数改为只容纳n个,超过的将删除 resize(int n,T val); //将容器的元素个数改为只容纳n个,超过的将删除,不够的以val的值来补全 capacity(); //返回当前向量所能容纳的最大元素值 (已经分配的数量)(指数扩容,2的次方) max_size(); //返回最大可允许的vector元素数量值(4611686018427387903) sort(); //排序,默认升序 sort(v.begin(),v.end(),cmp); //其中cmp为可选比较函数
-
三、deque(分段数组)[随机访问迭代器]
Vector 容器是单向开口的连续内存空间,deque 则是一种双向开口的连续线性空间。所谓的双向开口,意思是可以在头尾两端分别做元素的插入和删除操作,当然,vector 容器也可以在头尾两端插入元素,但是在其头部操作效率奇差,无法被接受。
deque 是由一段一段的定量的连续空间构成。一旦有必要在 deque 前端或者尾端增加新的空间,便配置一段连续定量的空间,串接在 deque 的头端或者尾端。Deque 最大的工作就是维护这些分段连续的内存空间的整体性的假象,并提供随机存取的接口,避开了重新配置空间,复制,释放的轮回,代价就是复杂的迭代器架构。
1、初始化:
#include <deque> deque<T>(); //一个空的容器 deque<T>(int Size); //设置元素个数 deque<T>(int Size,T value); //设置元素个数和初值 deque<T>(d.begin(),d.end()); //复制另一个容器
2、增:
push_front(T value); //头部加入 push_back(T value); //尾部加入 //迭代器 deque<T>::iterator it; insert(deque<T>::iterator it,T value);//在迭代器指向的元素前面插入 insert(deque<T>::iterator it,int n ,T value);//在迭代器指向的元素前面插入n个value insert(deque<T>::iterator it,d.begin(),d.end());//在迭代器指向的元素前面插入另一个vector的内容
3、删:
pop_front();//删除第一个元素 pop_back();//删除最后一个元素 clear(); //清空 //迭代器 deque<T>::iterator it; iterator erase(iterator it):删除向量中迭代器指向元素 iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
4、查:
T front(); //返回第一个元素 T back(); //返回最后一个元素 operator[int pos]; //返回pos位置的元素,下标表示,如果idx越界,不抛出异常,直接出错。 at(int pos); //返回pos位置的元素(不过一般都直接用下标表示) find(d.begin(), d.end(), key) != d.end() //遍历 for(int i = 0;i<d.size();++i){d[i];} for (auto &i : d){i;} //迭代器 deque<T>::iterator it; *it; //直接访问迭代器指向的元素 ++it; //双向迭代器特点 *(it+n); //随机迭代器特点 iterator begin(); //返回向量头指针,指向第一个元素 iterator end(); //返回向量尾指针,指向向量最后一个元素的下一个位置 //遍历 for (deque<int>::iterator it = d.begin(); it != d.end(); ++it) {tempNum = *it;} //反向遍历 for (deque<int>::reverse_iterator j = d.rbegin(); j != d.rend(); ++j) {tempNum = *it;}
5、改:
v[i] = (T)value; assign(int n,T x) //将容器全部内容改为n个x swap(deque<T>); //交换两个同类型向量的数据 //迭代器 deque<T>::iterator it; *it = (T)value; assign(d.begin(),d.end()) //容器中[first,last)中元素设置成当前向量元素
6、其他方法:
empty(); //是否为空 size(); //返回元素个数 resize(int n); //将容器的元素个数改为只容纳n个,超过的将删除 resize(int n,T val); //将容器的元素个数改为只容纳n个,超过的将删除,不够的以val的值来补全 capacity(); //返回当前向量所能容纳的最大元素值 (已经分配的数量)(指数扩容,2的次方) max_size(); //返回最大可允许的vector元素数量值(4611686018427387903) sort(); //排序,默认升序 sort(d.begin(),d.end(),cmp); //其中cmp为可选比较函数
-
四、list(双向链表)[双向迭代器]
list 是顺序容器的一种。list 是一个双向链表。使用 list 需要包含头文件 list。双向链表的每个元素中都有一个指针指向后一个元素,也有一个指针指向前一个元素。
在 list 容器中,在已经定位到要增删元素的位置的情况下,增删元素能在常数时间内完成。
1、初始化
#include <list> list<T>(); //一个空的列表 list<T>(int Size); //设置列表个数 list<T>(int Size,T value); //设置列表个数和初值 list<T>(l.begin(),l.end()); //复制另一个列表
2、增:
push_front(T value); //头部加入 push_back(T value); //尾部加入 //迭代器 list<T>::iterator it; insert(list<T>::iterator it,T value);//在迭代器指向的元素前面插入 insert(list<T>::iterator it,int n ,T value);//在迭代器指向的元素前面插入n个value insert(list<T>::iterator it,l.begin(),l.end());//在迭代器指向的元素前面插入另一个list的内容
3、删:
pop_front();//删除第一个元素 pop_back(); //删除最后一个元素 clear(); //清空 //迭代器 list<T>::iterator it; iterator erase(iterator it):删除向量中迭代器指向元素 iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
4、查:
T front(); //返回第一个元素 T back(); //返回最后一个元素 find(l.begin(), l.end(), key) != l.end()//根据value查找值,如果找不到会返回l.end()的值 //遍历 for (auto &i : v){i;} //迭代器 list<T>::iterator it; *it; //直接访问迭代器指向的元素 ++it; //双向迭代器特点 iterator begin(); //返回向量头指针,指向第一个元素 iterator end(); //返回向量尾指针,指向向量最后一个元素的下一个位置 //遍历 for (ist<int>::iterator it = l.begin(); it != l.end(); ++it) {tempNum = *it;} //反向遍历 for (list<int>::reverse_iterator j = l.rbegin(); j != l.rend(); ++j) {tempNum = *it;}
5、改:
assign(int n,T x) //将容器全部内容改为n个x swap(list<T>); //交换两个同类型向量的数据 //迭代器 list<T>::iterator it; *it = (T)value; assign(l.begin(),l.end()) //容器中[first,last)中元素设置成当前向量元素
6、其他方法:
empty(); //是否为空 size(); //返回元素个数 resize(int n); //将容器的元素个数改为只容纳n个,超过的将删除 resize(int n,T val); //将容器的元素个数改为只容纳n个,超过的将删除,不够的以val的值来补全 max_size(); //返回最大可允许的list元素数量值(768614336404564650)
-
五、stack(基于deque)[不支持迭代器]
stack<T>容器适配器中的数据是以 LIFO 的方式组织的。只能访问 stack 顶部的元素;只有在移除 stack 顶部的元素后,才能访问下方的元素。
1、初始化
#include <stack> stack<T>(); //一个空的栈 stack<T>(stack<T> s); //复制
2、增:
push(T value); //加入栈顶的元素
3、删:
pop(); //删除栈顶的元素
4、查:
top(); //返回栈顶的元素
5、改:
swap(stack<T>); //交换两个同类型向量的数据
6、其他方法:
empty(); //是否为空 size(); //返回元素个数
-
六、queue(基于deque)[不支持迭代器]
只能访问 queue<T> 容器适配器的第一个和最后一个元素。只能在容器的末尾添加新元素,只能从头部移除元素
对于任何需要用 FIFO 准则处理的序列来说,使用 queue 容器适配器都是好的选择
1、初始化
#include <queue> queue<T>(); //一个空的队列 queue<T>(queue<T> q); //复制
2、增:
push(T value); //尾部加入元素
3、删:
pop(); //删除第一个元素
4、查:
front(); //返回第一个元素 back(); //返回最后的元素
5、改:
swap(queue<T>); //交换两个同类型向量的数据
6、其他方法:
empty(); //是否为空 size(); //返回元素个数
-
七、priority_queue(基于vector)[不支持迭代器]
priority_queue 容器适配器定义了一个元素有序排列的队列。默认队列头部的元素优先级最高。因为它是一个队列,所以只能访问第一个元素,这也意味着优先级最高的元素总是第一个被处理。但是如何定义“优先级”完全取决于我们自己。
1、初始化
#include <queue> priority_queue<T, Container, Functional>(); //T 就是数据类型,Container 就是容器类型(Container必须是用数组实现的容器,比如vector,deque等等,但不能用 list。STL里面默认用的是vector),Functional 就是比较的方式。 priority_queue<T, Container, Functional>(priority_queue<T, Container, Functional> pq);//复制 //升序队列,小顶堆 priority_queue <T,vector<T>,greater<T>> q; //降序队列,大顶堆 priority_queue <T,vector<T>,less<T>> q; //greater和less是std实现的两个仿函数(就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator(),这个类就有了类似函数的行为,就是一个仿函数类了)需要#include <functional>
2、增:
push(T value); //加入元素(并排序)
3、删:
pop(); //删除第一个元素
4、查:
top(); //返回第一个元素
5、改:
swap(priority_queue<T>); //交换两个同类型向量的数据
6、其他方法:
empty(); //是否为空 size(); //返回元素个数
-
八、map(基于红黑树)[双向迭代器]
map是STL的一个关联容器,它提供一对一的hash。第一个可以称为关键字(key),每个关键字只能在map中出现一次;第二个可能称为该关键字的值(value);
map內部的实现自建一颗红黑树,这颗树具有对数据自动排序的功能。在map内部所有的数据都是有序的
1、初始化
#include <map> map<T1,T2>(); //一个空的map map<T1, T2>(m.begin(),m.end()); //复制另一个map map<T1, T2> m = { {T1 value1, T2 value2},{T1 value1, T2 value2},...,}//直接初始化
2、增:
//使用pair插入 注意map中有这个关键字时,insert操作是不能在插入数据的 insert(make_pair<T1, T2>(T1 value1,T2 value2); insert(pair<T1, T2>(T1 value1,T2 value2); //使用value_type插入 注意map中有这个关键字时,insert操作是不能在插入数据的 insert(map<T1, T2>::value_type (T1 value1, T2 value2)); //用"array"方式插入,可以直接覆盖 m[T1 value1] = T2 value2;
3、删:
erase(T1 value); //如果刪除了會返回1,否則返回0 clear(); //清空 //迭代器 map<T1,T2>::iterator it; iterator erase(iterator it):删除向量中迭代器指向元素 iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
4、查:
find(key) != m.end(); //根据value查找值,如果找不到会返回l.end()的值 at(T1 value1); //返回的是参数键对应的对象。如果这个键不存在,就会拋出 out_of_range 异常 //遍历 for (auto &i : v){i.first;i.second} //迭代器 map<T1,T2>::iterator it; it->first; //访问key it->second; //访问value ++it; //双向迭代器特点 iterator begin(); //返回向量头指针,指向第一个元素 iterator end(); //返回向量尾指针,指向向量最后一个元素的下一个位置 //遍历 for (map<T1,T2>::iterator it = m.begin(); it != m.end(); ++it) {key = it->first;value = it->second;} //反向遍历 for (map<T1,T2>::reverse_iterator j = m.rbegin(); j != m.rend(); ++j) {key = it->first;value = it->second;}
5、改:
swap(map<T1,T2>) //交换两个同类型向量的数据 //使用array方式直接修改 m[T1 value1] = T2 value2; //迭代器 map<T1,T2>::iterator it; it->second = T2 alue;
6、其他方法:
empty(); //是否为空 count(T1 value1); //返回指定元素出现的次数 size(); //返回元素个数 max_size(); //返回最大可允许的map元素数量值(256204778801521550)
-
九、multimap(基于红黑树)[双向迭代器]
multimap容器:与map容器类似,区别只在于multimap容器可以保存键值相同的元素。
1、初始化
#include <map> multimap<T1,T2>(); //一个空的multimap multimap<T1, T2>(m.begin(),m.end()); //复制另一个multimap multimap<T1, T2> m = { {T1 value1, T2 value2},{T1 value1, T2 value2},...,}//直接初始化
2、增:
//multimap 容器的成员函数 insert() 可以插入一个或多个元素,而且插入总是成功。 //使用pair插入 insert(make_pair<T1, T2>(T1 value1,T2 value2); insert(pair<T1, T2>(T1 value1,T2 value2); //使用value_type插入 insert(multimap<T1, T2>::value_type (T1 value1, T2 value2));
3、删:
erase(T1 value); //如果刪除了會返回1,否則返回0 clear(); //清空 //迭代器 multimap<T1,T2>::iterator it; iterator erase(iterator it):删除向量中迭代器指向元素 iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
4、查:
find(key) != m.end(); //根据value查找值,如果找不到会返回l.end()的值 //遍历 for (auto &i : v){i.first;i.second} //迭代器 multimap<T1,T2>::iterator it; it->first; //访问key it->second; //访问value ++it; //双向迭代器特点 iterator begin(); //返回向量头指针,指向第一个元素 iterator end(); //返回向量尾指针,指向向量最后一个元素的下一个位置 //遍历 for (multimap<T1,T2>::iterator it = m.begin(); it != m.end(); ++it) {key = it->first;value = it->second;} //反向遍历 for (multimap<T1,T2>::reverse_iterator j = m.rbegin(); j != m.rend(); ++j) {key = it->first;value = it->second;}
5、改:
swap(map<T1,T2>) //交换两个同类型向量的数据 //迭代器 multimap<T1,T2>::iterator it; it->second = T2 alue;
6、其他方法:
empty(); //是否为空 count(T1 value1); //返回指定元素出现的次数 size(); //返回元素个数 max_size(); //返回最大可允许的map元素数量值(256204778801521550)
-
十、unordered_map(基于hash表)[正向迭代器]
unordered_map 包含的是有唯一键的键/值对元素。容器中的元素不是有序的。元素的位置由键的哈希值确定,因而必须有一个适用于键类型的哈希函数。如果用类对象作为键,需要为它定义一个实现了哈希函数的函数对象。如果键是STL 提供的类型,通过特例化 hash<T>,容器可以生成这种键对应的哈希函数
1、初始化
#include <unordered_map > unordered_map <T1,T2>(); //一个空的map unordered_map <T1, T2>(m.begin(),m.end()); //复制另一个map unordered_map <T1, T2> m = { {T1 value1, T2 value2},{T1 value1, T2 value2},...,}//直接初始化
2、增:
//使用pair插入 注意map中有这个关键字时,insert操作是不能在插入数据的 insert(make_pair<T1, T2>(T1 value1,T2 value2); insert(pair<T1, T2>(T1 value1,T2 value2); //使用value_type插入 注意map中有这个关键字时,insert操作是不能在插入数据的 insert(unordered_map<T1, T2>::value_type (T1 value1, T2 value2)); //用"array"方式插入,可以直接覆盖 m[T1 value1] = T2 value2;
3、删:
erase(T1 value); //如果刪除了會返回1,否則返回0 clear(); //清空 //迭代器 unordered_map<T1,T2>::iterator it; iterator erase(iterator it):删除向量中迭代器指向元素 iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
4、查:
find(key) != m.end(); //根据value查找值,如果找不到会返回l.end()的值 at(T1 value1); //返回的是参数键对应的对象。如果这个键不存在,就会拋出 out_of_range 异常 //遍历 for (auto &i : v){i.first;i.second} //迭代器 unordered_map<T1,T2>::iterator it; it->first; //访问key it->second; //访问value ++it; //双向迭代器特点 iterator begin(); //返回向量头指针,指向第一个元素 iterator end(); //返回向量尾指针,指向向量最后一个元素的下一个位置 //遍历 for (unordered_map<T1,T2>::iterator it = m.begin(); it != m.end(); ++it) {key = it->first;value = it->second;}
5、改:
swap(unordered_map<T1,T2>) //交换两个同类型向量的数据 //使用array方式直接修改 m[T1 value1] = T2 value2; //迭代器 unordered_map<T1,T2>::iterator it; it->second = T2 alue;
6、其他方法:
empty(); //是否为空 count(T1 value1); //返回指定元素出现的次数 size(); //返回元素个数 max_size(); //返回最大可允许的map元素数量值(256204778801521550)
-
十一、set(基于红黑树)[双向迭代器]
set为集合。除了没有单独的键,set 容器和 map 容器很相似。
1、初始化
#include <set> set<T>(); //一个空的map set<T>(s.begin(),s.end()); //复制另一个map set<T> s = { T value,T value,...,}//直接初始化
2、增:
//无法重复插入 insert(T value); //插入元素 emplace(T value); //插入元素,会返回一个 pair<iterator,bool> 对象
3、删:
erase(T value); //如果刪除了會返回1,否則返回0 clear(); //清空 //迭代器 set<T>::iterator it; iterator erase(iterator it):删除向量中迭代器指向元素 iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
4、查:
find(key) != s.end(); //根据value查找值,如果找不到会返回l.end()的值 //遍历 for (auto &i : s){i} //迭代器 set<T>::iterator it; *it //直接访问迭代器指向的元素 ++it; //双向迭代器特点 iterator begin(); //返回向量头指针,指向第一个元素 iterator end(); //返回向量尾指针,指向向量最后一个元素的下一个位置 //遍历 for (set<T>::iterator it = s.begin(); it != s.end(); ++it) {temp = *it;} //反向遍历 for (set<T>::reverse_iterator j = s.rbegin(); j != s.rend(); ++j) {temp = *it;}
5、改:
swap(set<T>) //交换两个同类型向量的数据
6、其他方法:
empty(); //是否为空 count(T value); //返回指定元素出现的次数 size(); //返回元素个数 max_size(); //返回最大可允许的set元素数量值
-
十二、multiset(基于红黑树)[双向迭代器]
multiset容器:与set容器类似,区别只在于multiset容器可以保存相同的元素。
1、初始化
#include <set> multiset<T>(); //一个空的map multiset<T>(s.begin(),s.end()); //复制另一个map multiset<T> s = { T value,T value,...,}//直接初始化
2、增:
//总是能够成功 insert(T value); //插入元素 emplace(T value); //插入元素,会返回一个 pair<iterator,bool> 对象
3、删:
erase(T value); //如果刪除了會返回1,否則返回0 clear(); //清空 //迭代器 multiset<T>::iterator it; iterator erase(iterator it):删除向量中迭代器指向元素 iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
4、查:
find(key) != s.end(); //根据value查找值,如果找不到会返回l.end()的值 //遍历 for (auto &i : s){i} //迭代器 set<T>::iterator it; *it //直接访问迭代器指向的元素 ++it; //双向迭代器特点 iterator begin(); //返回向量头指针,指向第一个元素 iterator end(); //返回向量尾指针,指向向量最后一个元素的下一个位置 //遍历 for (multiset<T>::iterator it = s.begin(); it != s.end(); ++it) {temp = *it;} //反向遍历 for (multiset<T>::reverse_iterator j = s.rbegin(); j != s.rend(); ++j) {temp = *it;}
5、改:
swap(multiset<T>) //交换两个同类型向量的数据
6、其他方法:
empty(); //是否为空 count(T value); //返回指定元素出现的次数 size(); //返回元素个数 max_size(); //返回最大可允许的multiset元素数量值
-
十三、unordered_set(基于hash表)[正向迭代器]
占位
(其实可以直接参考unordered_map和set的方法直接用)
-
十四、string
占位
有点懒得整理了:http://c.biancheng.net/view/400.html
-
参考资料
大多数都从这里整理的:C++笔记 http://c.biancheng.net/skill/cpp/
等什么时候想起来再把后两个补了(摸了)
-
(为什么会有人把目录放最后
一、迭代器(针对容器的一种指针)
二、VECTOR(简单数组)[随机访问迭代器]
三、DEQUE(分段数组)[随机访问迭代器]
四、LIST(双向链表)[双向迭代器]
五、STACK(基于DEQUE)[不支持迭代器]
六、QUEUE(基于DEQUE)[不支持迭代器]
七、PRIORITY_QUEUE(基于VECTOR)[不支持迭代器]
八、MAP(基于红黑树)[双向迭代器]
九、MULTIMAP(基于红黑树)[双向迭代器]
十、UNORDERED_MAP(基于HASH表)[正向迭代器]
十一、SET(基于红黑树)[双向迭代器]
十二、MULTISET(基于红黑树)[双向迭代器]
十三、UNORDERED_SET(基于HASH表)[正向迭代器]
十四、STRING