1. 顺序容器 STL deque 类
   1.deque 是一个动态数组
   2.deque与vector非常类似
   3.deque可以在数组开头和末尾插入和删除数据

问：如何创建一个动态数组?
答：deque<数据类型>数组名；
例如：deque<数据类型>a;

问：如何插入数据？
答：
数组名.push_back(值);//这是在末尾插入数据
数组名.push_front(值);//这是在开头插入数据

问：如果删除数据？
答：
数组名.pop_back();//这是删除末尾数据
数组名.pop_front();//这是删除开头数据

2.顺序容器 STL list 类
1.实例化std::list对象
2.在list开头插入元素
3.在list末尾插入元素
4.在list中间插入元素
5.删除list中的元素
6.对list中元素进行反转和排序

1.实例化对象：std::list<数据类型>对象名；
2.开头插入和末尾插入元素和deque一样
2.中间插入用inser（位置，个数，值）
4.删除用 对象名.erase（位置1，位置2）//位置1会被删除，位置2不会被删除
5.链表里的元素反转：对象名.reverse（）；
6.链表里的元素排序：对象名.sort();

3.STL stack
1.（堆）栈：LIFO后进先出
2.自适应容器（容器适配器）
3.栈适配器 STL stack
语法：
1.stack<数据类型,deque<数据类型>> s;
2.stack<数据类型,vector<数据类型>> s;
3.stack<数据类型,list<数据类型>> s;
4.s.empty()//检查堆栈是不是空的，返回false或者true
5.s.size()//查看栈里有多少个数据
6.s.pop()//删除栈顶的数据
7.s.top()//查看栈顶的数据
8.s.push(item)//把数据放入栈中

STL queue
1.队列：FIFO先进先出,后进后出
2.自适应容器（容器适配器）
3.栈适配器 STL queue
语法：
1.queue<数据类型,deque<数据类型>> q;
2.queue<数据类型,list<数据类型>> q;
3.q.empty()
4.q.size()
5.q.front()
6.q.back()
7.q.pop()
8.q.push(item)

STL 优先级队列 priority_queue
1.自适应容器（容器适配器）：不能使用list
2.最大值优先级队列、最小值优先级队列
3.优先级队列适配器：STL priority_queue
语法：
1.priority_queue<数据类型,deque<数据类型>> pq;//最大值优先级队列
priority_queue<数据类型,deque<数据类型>，greater<数据类型>> pq;//最小值优先级队列
2.priority_queue<数据类型,vector<数据类型>> pq;
3.pq.empty()
4.pq.size()
5.pq.top()
6.pq.pop()
7.pq.push(item)

顺序容器的定义
1.顺序容器：vector,list,deque
2.顺序容器适配器：stack,queue,priority_queue

迭代器和迭代器范围
1.每一种容器都有自己的迭代器
2.所有的迭代器接口都是一样的
3.在整个标准库中，经常使用形参为一对迭代器的构造函数
4.常用的迭代器操作：*iter,++iter,–iter,iter1==iter2,iter1!=iter2
5.vector和deque容器的迭代器的额外操作：iter+n,iter-n,>,>=,<,<=
6.迭代器范围:begin/end,first/last //前包后不包
7.使迭代器失效的容器操作

顺序容器的操作
1.容器定义的类型别名
2.begin和end成员
顺序容器：vector,list,deque
1.vector:
1.vector<数据类型>::size_type a1;
2.vector<数据类型>::iterator a2;
3.vector<数据类型>::const_iterator a3;
4.vector<数据类型>::reverse_iterator a4;
5.vector<数据类型>::const_reverse_iterator a5;
6.vector<数据类型>::difference_type a6;
7.vector<数据类型>::value_type a7;//要初始化
8.vector<数据类型>::reference a8;//要初始化
9.vector<数据类型>::const_reference a9;//要初始化

2.list:
1.list<数据类型>::size_type b1;
2.list<数据类型>::iterator b2;
3.list<数据类型>::const_iterator b3;
4.list<数据类型>::reverse_iterator b4;
5.list<数据类型>::const_reverse_iterator b5;
6.list<数据类型>::difference_type b6;
7.list<数据类型>::value_type b7;//要初始化
8.list<数据类型>::reference b8;//要初始化
9.list<数据类型>::const_reference b9;//要初始化

3.deque:
1.deque<数据类型>::size_type c1;
2.deque<数据类型>::iterator c2;
3.deque<数据类型>::const_iterator c3;
4.deque<数据类型>::reverse_iterator c4;
5.deque<数据类型>::const_reverse_iterator c5;
6.deque<数据类型>::difference_type c6;
7.deque<数据类型>::value_type c7;//要初始化
8.deque<数据类型>::reference c8;//要初始化
9.deque<数据类型>::const_reference c9;//要初始化

顺序容器的操作
1.在顺序容器中添加元素
c.push_back(t)
c.push_front(t)
c.insert(p,t)
c.insert(p,n,t)
c.insert(p,b,e)
2.容器元素都是副本
3.添加元素可能会使迭代器失效（意思是如果添加元素会使得迭代器原来最后一个元素不是最新的最后一个元素）
4.避免存储end操作返回的迭代器

顺序容器的操作
1.关系运算符
2.所有的容器类型都可以使用
3.比较的容器必须具有相同的容器类型
4.容器的比较是基于容器内元素的比较
5.容器内元素必须有相应的关系运算符

顺序容器的操作
1.容器名.size()
2.容器名.max_size()
3.容器名.empty()
4.容器名.resize(n)
5.容器名.resize(n,t)
注意：resize操作可能会使迭代器失效、

顺序容器的操作
访问元素
1.容器名.back()
2.容器名.front()
3.容器名[n]
4.容器名.at(n)
注意：容器名[n]和容器名.at(n)只适合vector和deque容器