1、vector基本操作
关于vector简单的讲就是一个动态增长的数组，里面有一个指针指向一片连续的内存空间，当空间装不下的时候会自动申请一片更大的空间（空间配置器）将原来的数据拷贝到新的空间，然后就会释放旧的空间。当删除的时候空间并不会被释放只是清空了里面的数据。
- 对象初始化，使用 v1 中的数据：vector<int> vec(v1.begin(), v1.begin()+3);
- 末尾添加元素： vec.push_back();
- 末尾删除元素： vec.pop_back();
- 任意位置插入元素： vec.insert();
- 任意位置删除元素： vec.erase();
- 交换两个向量的元素： vec.swap();
- 清空向量元素： vec.clear();
#include<vector> //包含头文件 vector<int> vec_one; //最简单vector实例定义 int nLen = 10; vector<int> vec_fir(nLen); //分配nLen个空间，并且每个空间初始化为0（默认值） int nData1 = vec_fir.front(); //查询vector中第一个元素 int nData2 = vec_fir.back(); //查询vector中最后一个个元素 int nData3 = vec_fir.at(8); //查询vector中索引为8（即第9个）元素 int nData4 = vec_fir[8]; //同上，operator[]运算符重载 vec_fir.assign(10,2); //重新赋值vec_fir实例中数据为10个2 vec_fir.assign(vec_sed.begin(),vec_sed.end()); //重新赋值vec_fir为vec_sed vec_fir.push_back(10) //vector尾部添加一个10数据 vec_fir.pop_back() //删除vector尾部一个数据 vec_fir.erase(vec_fir.begin()); //删除vec_fir第一个数据（索引删除），指定位置删除，返回下一个数据的位置 vec_fir.erase(vec_fir.begin(),vec_fir.begin()+5); //删除vec_fir第一个到第五个间断数据，返回下一个数据的位置
vec_fir.insert(vec_fir.begin(),10086); //开始位置插入一个10086数据 vec_fir.insert(vec_fir.begin(),10,99); //开始位置插入10个初始化为99的数据集 vec_fir.insert(vec_fir.begin(),vec_sed.begin(), vec_sed.begin()+5); //将vec_sed开始的5个数插入在vec_fir开头
vec_fir.size(); //求解vector数据个数 //重新定义空间大小为100个空间，空间增加了则新增空间初始化为0，缩小了就仅保留前100个数据 vec_fir.resize(100); vec_fir.clear(); // 清空vector vec_fir.swap(vec_sed); //交换两个vector中所有数据
（1）vector容器实现迭代器，元素遍历
- 开始指针：vec.begin();
- 末尾指针：vec.end(); //指向最后一个元素的下一个位置
//正向迭代器，输出：1 3 5 7 9 vector<int>::iterator it; for (it = vec.begin(); it != vec.end(); it++) cout << *it << endl; //反向迭代器，输出：9 7 5 3 1 vector<int>::reverse_iterator rit; for (rit = vec.rbegin(); rit != vec.rend(); rit++) cout << *rit << endl; //常规的循环输出，输出：1 3 5 7 9 for (int i = 0; i < vec.size(); ++i) { cout << vec[i] << endl; }
（2）几种重要的操作
头文件要包含：#include<algorithm>（1）sort(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素进行从小到大排列
（2）reverse(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素为1,3,2,4,倒置后为4,2,3,1
（3）copy(a.begin(),a.end(),b.begin()+1); //把a中的从a.begin()（包括它）到a.end()（不包括它）的元素复制到b中，从b.begin()+1的位置（包括它）开始复制，覆盖掉原有元素
（4）find(a.begin(),a.end(),10); //在a中的从a.begin()（包括它）到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置
2、list基本操作
list中各个元素之间也存在一个线性的逻辑次序，但是与vector极其不同的是，各单元的物理地址可以任意，无需是连续的空间分配。
这个算是一个技巧的介绍，有时候为了方便程序维护与以后修改，我们可以在程序头类型定义对应的模板类为一个简化名称（一般大写表示），如下。这样的好处就是一旦后面我们想用list<long>定义我们的变量，只需在此修改list<int>为list<long>，从而不需要整个程序中修改了。此外取一个通俗易懂的名称也会增加程序的通读行。
#include<list> typedef list<int> INTLIST; typerdef vector<long> LONGVECTOR; typerdef list<int>::iterator INTLISTITER; INTLIST list_fir; //声明一个list<int>对象
list<int> list_fir; //或者INTLIST list_fir，这里不去简写 list<int> list_sed(10,2); // 申请10个空间，全部初始化为2 list<int> list_thd(list_fir); //拷贝构造 vector<int> vec(10,1); list<int> list_for(vec.begin(),vec.end()); //拷贝vector一段数据初始化
//拼接方法 list_fir.merge(list_sed); // 拼接加在list_fir上，而list_sed变为空 list_fir.splice(list_fir.begin(),list_sed); //在list_fir初始位置拼接上list_sed list_fir.push_back(110); //尾部增加一个110数 list_fir.push_front(1); //首部增加一个1数 list_fir.pop_back(); //尾部删除一个数 list_fir.pop_front(); //首部删除一个数 //访问 int data1 = list_fir.front(); // 第一个数 int data2 = list_fir.back(); // 最后一个数 list<int>::iterator iter; for(iter=list_fir.begin();iter!=list_end();iter++) { cout<<*iter<<endl; //就像指针一样*间接访问每个数 }
size_t = list_fir.size(); // 统计list中数据个数 list_fir.unique(); // 链表中每个连续出现的数仅保留第一次出现的那个 if(!list_fir.empty()) // 判断链表中是否为空 { list_fir.clear(); // 清空链表 } list_fir.swap(list_sed);// 交换两个链表所有数据 list_fir.sort(); // 增序排序整个链表
list_fir.insert(list_fir.front()+3, 100); // 插入元素100,是将第三个元素放到第四个上，依次类推，把100放到第三个元素上
list_fir.erase(beg, end) // 删除区间内的数据，左闭右开，返回下一个数据的位置，比如：0 1 2 3 4 5，beg=0，end=3 ，删除后结果为：3 4 5
list_fir.erase(pos) // 删除该位置的数据，返回下一个数据的位置
list_fir.remove(elem) // 删除容器中 所有与 elem 值相匹配的元素
3、双向队列 — deque
deque双向队列是一种双向开口的连续线性空间，可以高效的在头尾两端插入和删除元素，deque在STL中接口上和vector非常相似，此外它还是STL中queue和stack的底层依赖组件。
deque拥有一个bitmap结构（称之为map，并不是STL中容器map），map中每一个元素指向一块连续的内存块，后者才是真正存储deque元素的地方，因为每个块都是固定大小的，但是每个块之间不要求是连续的，所以扩充空间的时候，就没有vector那样的副作用了，即无需“配置新空间 / 移动旧数据 / 释放旧空间”的一套过程。
#include<deque> deque<string> deq_fir; cout<<deq_fir[2]<<endl; //同样是查询下标为2的元素，即第三个元素 cout<<deq_fir.front()<<endl; //查询第一个元素 cout<<deq_fir.back()<<endl; //查询最后一个元素 deq_fir.erase(deq_fir.begin()+5); //删除第五个元素 deq_fir.erase(deq_fir.begin(),deq_fir.begin()+3); //删除前三个元素
deq_fir.insert(deq_fir.begin(),10,"banana!"); //首部插入10个"banana!"字符串 deq_Fir.insert(deq_fir.end(),"apple!"); //尾部插入一个“apple!”字符串 deq_fir.push_back("hello"); //尾部添加字符串 deq_fir.push_front("world!");//首部添加字符串 deq_fir.pop_back(); //尾部删除一个元素 deq_fir.pop_front(); //首部删除一个元素
if(!deq_fir.empty()) // 判断是否为空deque { deq_fir.clear(); // 清空操作 } if(deq_fir.size() > 10) // 查询空间元素个数 deq_fir.resize(10); // 重新定义deque空间大小到10 deq_fir.swap(deq_sed); // 交换两个deque中所有数据
//正向迭代器，输出：1 3 5 7 9 deque<int>::iterator it; for (it = deq.begin(); it != deq.end(); it++) cout << *it << endl; // 查找数组中 某个元素 的位置下标 it = find(deq.begin(), deq.end(), 5); if (it != deq.end()) { cout << "5数组的下标为：" << distance(deq.begin(), it) << endl; } else { cout << "n没有找到5的元素" << endl; }
4、queue基本操作
它是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的尾端进行入队，而在首端进行出队。
#include<queue> queue<int> que_fir; queue<double> que_sed;
que_fir.push(1); // 放入一个元素1在队列尾部 que_fir.pop(); // 删除队首一个元素 que_fir.back(); // 访问队尾元素 que_fir.front(); // 访问队首元素 if(!que_fir.empty()); // 判断队列是否为空 que_fir.swap(que_sed); // 完全交换两个队列中数据，当然两个队列中保存的必须是一种数据类型 que_fir.size(); // 队列中元素个数
5、stack基本操作
栈只有一个出口，像下面一摞椅子一样，只能在栈顶上增加元素，也只能从栈顶移出元素和访问元素。
#include<stack> stack<int> stk_fir; stack<string> stk_sed; stk_fir.push(10086); // 栈顶入栈元素10086 stk_fir.pop(); // 删除一个栈顶元素 stk_fir.top(); // 访问栈顶一个元素（而queue可以访问队首和队尾，分别是front()和back()方法） stk_fir.size(); // 返回栈中元素个数 stk_fir.swap(stk_thd); // 交换两个相同类型的stack中所有数据 stk_fir.empty(); // 栈中为空则返回true
6、priority_queue基本操作
#include<queue>
priority_queue<int> que1; // 普通构造，默认是大顶堆 priority_queue<int, vector<int>, less<int>> //大顶堆：表示其他都比堆顶小 priority_queue<int, vector<int>, greater<int>> //小顶堆：表示其他都比堆顶大
que1.empty( ); // 判断队列是否为空 que1.pop( ); // 删除队顶元素 que1.push( ); // 加入一个元素 que1.size( ); // 返回优先队列中拥有的元素个数 que1.top( ); // 返回队顶元素,接口和stack名一样。而queue中是front()和back()
7、map（红黑树）
#include<map> map<int,float> map_sed; map_sed.insert(pair<int,float>(100 , 0.1234)); //方法一，当map中有这个关键字就不可以操作 map_sed.insert(map<int,float>::value_type(110,100.86)); //方法二，同方法一 map_sed[120] = 10000; // 方法三，可以重载
当然前两种方式是一样的，都是用insert函数插入数据。但是数据的插入涉及到集合的唯一性这个概念，即当map中有这个关键字时，insert操作是插入数据不了的，但是用operator[]重载的方式就不同了，它可以覆盖以前该关键字对应的值。
map<int,float> map_fir; map_fir.swap(map_sed); // 交换所有数据，需要确保map中元素类型相同 map_fir.clear(); // 清空map_fir map_fir.size(); // 统计map_fir中元素个数 map_fir.empty(); // 判断map中是否为空，如果是空则返回1
参考：https://blog.csdn.net/column/details/16577.html