vector是封装动态数组的顺序容器。元素相继存储，这意味着不仅可通过迭代器，还能用指向元素的常规指针访问元素。这意味着指向 vector 元素的指针能传递给任何期待指向数组元素的指针的函数。

//空的vector容器
vector<int>v1;
//size为5，值的初始化为0的vector容器
vector<int>v2(5);
//size为5，值的初始化为1的vector容器
vector<int>v3(5, 1);
//创建vector时就初始化
vector<int>v4 = { 1,3,4,5,7 };
//利用别的vector创建初始化vector
vector<int>v5(v4);
//指定起始与结束内容创建与初始化
vector<int>v6(v4.begin()+3, v4.end());

begin() 返回第一个元素的迭代器 
end() 返回最末元素的迭代器 
rbegin() 返回Vector尾部的逆迭代器 
rend() 返回Vector起始的逆迭代器 

v.at(i)	//返回vector v指定位置的元素
v[i]	//返回vector v指定位置的元素
v.back() //返回最末一个元素 
v.front() //返回第一个元素 

void push_back( const TYPE &val ); //在Vector最后添加一个元素 
void pop_back(); //移除最后一个元素 
iterator erase( iterator loc );	//删除指定loc元素
iterator erase( iterator start, iterator end );	//删除[start,end)元素

v.push_back(3);	//vector最后添加元素3
v.pop_back();	//删除vector最后一个元素
v.erase(v.begin());//删除位置为begin的元素
v.erase(v.begin(),v.end());//删除区间[begin(),end())的元素

//在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器, 
iterator insert( iterator loc, const TYPE &val );
//在指定位置loc前插入num个值为val的元素 
void insert( iterator loc, size_type num, const TYPE &val );
//在指定位置loc前插入区间[start, end)的所有元素
void insert( iterator loc, input_iterator start, input_iterator end );

v.insert(v.begin(),1);//在begin()位置插入元素1
v.insert(v.begin(),5,1);//在begin()位置插入5个值为1的元素
v.insert(v.begin(),v1.begin(),v1.end());//在begin()位置插入区间[v1.begin(),v1.end())的元素

是有下标顺序容器，它允许在其首尾两段快速插入及删除。另外，在 deque 任一端插入或删除不会非法化指向其余元素的指针或引用。

//无参，创建一个空双向队列 
deque();
//size - 创建一个大小为size的双向队列 
deque( size_type size );
//num and val - 放置num个val的拷贝到队列中 
deque( size_type num, const TYPE &val );
//from - 从from创建一个内容一样的双向队列 
deque( const deque &from );
//start 和 end - 创建一个队列，保存从start到end的元素
deque( input_iterator start, input_iterator end );

deque<int>d1;//空双向队列
deque<int>d2(5);//大小为5，值为0的双向队列
deque<int>d3(5,1);//大小为5，值为1的双向队列
deque<int>d4(d3);//创建一个与d3相同的双向队列
deque<int>d5(d3.begin(),d3.end());
deque<int>d6 = {1,4,6,8};//初始化队列

begin() 返回第一个元素的迭代器 
end() 返回最末元素的迭代器 
rbegin() 返回尾部的逆迭代器 
rend() 返回起始的逆迭代器 

d.at(i)	//返回指定位置的元素
d[i]	//返回指定位置的元素
d.back() //返回最末一个元素 
d.front() //返回第一个元素 

void push_back( const TYPE &val ); //在最后添加一个元素 
void pop_back(); //移除最后一个元素 
void push_front( const TYPE &val ); //在头部加入一个元素 
void pop_front(); //删除头部的元素 
iterator erase( iterator loc );	//删除指定loc元素
iterator erase( iterator start, iterator end );	//删除[start,end)元素
iterator emplace( const_iterator pos, Args&&... args );



d.push_back(3);	//最后添加元素3
d.pop_back();	//删除最后一个元素
d.push_front(1)	//首元素添加元素1
d.pop_front();	//删除首元素
d.erase(d.begin());//删除位置为begin的元素
d.erase(d.begin(),d.end());//删除区间[begin(),end())的元素

//在位置为pos插入元素val
iterator insert( iterator pos, const TYPE &val );
//在位置为pos插入num个值为val元素
iterator insert( iterator pos, size_type num, const TYPE &val );
//在位置pos插入区间[start,end)
void insert( iterator pos, input_iterator start, input_iterator end );


//在begin位置插入元素1
d.insert(d.begin(),1);
//在begin位置插入5个值为1的元素
d.insert(d.begin(),5,1);
//在begin插入区间[d2.begin(),d2.end())
d.insert(d.begin(),d2.begin(),d2.end());

queue 是STL提供的队列容器

TYPE &back(); //返回最后一个元素 
bool empty();	//如果队列空则返回真 
TYPE &front() 返回第一个元素 
TYPE &pop() 删除第一个元素 
void push( const TYPE &val );在末尾加入一个元素 

功能就和普通的队列相同

优先队列类似队列，但是在这个数据结构中的元素按照一定的断言排列有序

priority_queue<Type>
priority_queue<Type, Container, Functional>    
其中Type 为数据类型， Container 为保存数据的容器，Functional 为元素比较方式。
Container 这里保存的容器一般用vector和deque

priority_queue<int> q;	//排序顺序默认为降序，也就是创建了大顶堆
priority_queue<int,vector<int>,less<int>> q;	//排序顺序为升序，创建了小顶堆

优先级队列，这个容器可以用set来实现。

该容器与现实数据结构stack相同

bool empty() 	//堆栈为空则返回真 
void pop(); 	//移除栈顶元素 
void push( const TYPE &val ); //在栈顶增加元素 
size_type size(); 	//返回栈中元素数目 
TYPE &top(); 	//返回栈顶元素 

List将元素按顺序储存在链表中. 与 vector相比, 它允许快速的插入和删除，但是随机访问却比较慢

list<T> lst; //list采用模板类实现对象的默认构造形式：
list(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem); //构造函数将n个elem拷贝给本身。
list(const list &lst); //拷贝构造函数。


list<int>L;	//空的list容器
list<int>L2(5);//大小为5值为0的容器
list<int>L3(5,1);//大小为5值为1的容器
list<int>L4(L3);//用L3创建容器
list<int>L5 = {1,4,6,8,4};//初始化容器

iterator begin();	//返回指向第一个元素的迭代器
iterator end()		//返回末尾的迭代器
iterator rbegin()	//返回指向第一个元素的逆向迭代器
iterator rend()		//返回list末尾的逆向迭代器

L.back() //返回最末一个元素 
L.front() //返回第一个元素 

void push_back( const TYPE &val ); //在最后添加一个元素 
void pop_back(); //移除最后一个元素 
void push_front( const TYPE &val ); //在头部加入一个元素 
void pop_front(); //删除头部的元素 
iterator erase( iterator loc );	//删除指定loc元素
iterator erase( iterator start, iterator end );	//删除[start,end)元素
void remove( const TYPE &val );	//删除所有的指定元素
void remove_if( UnPred pr );//以一元谓词pr为判断元素的依据，遍历整个链表。如果pr返回true则删除该元素




L.push_back(3);	//最后添加元素3
L.pop_back();	//删除最后一个元素
L.push_front(1)	//首元素添加元素1
L.pop_front();	//删除首元素
L.erase(d.begin());//删除位置为begin的元素
L.erase(d.begin(),d.end());//删除区间[begin(),end())的元素
L.remove(1);	//删除元素1
L.remove_if([](int n) { return n > 4; });	//删除大于4的元素

//在位置为pos插入元素val
iterator insert( iterator pos, const TYPE &val );
//在位置为pos插入num个值为val元素
iterator insert( iterator pos, size_type num, const TYPE &val );
//在位置pos插入区间[start,end)
void insert( iterator pos, input_iterator start, input_iterator end );


//在begin位置插入元素1
L.insert(L.begin(),1);
//在begin位置插入5个值为1的元素
L.insert(L.begin(),5,1);
//在begin插入区间[L2.begin(),L2.end())
L.insert(L.begin(),L2.begin(),L2.end());

merge()合并两个list，要求两个list必须有序；
splice()不需要list有序，splice()不复制或移动元素，仅重指向链表结点的内部指针
可以用advance调整iterator 的位置

void merge( list &lst );	//合并两个list必须有序，默认是升序，被合并list会被清空
void merge( list &lst, Comp compfunction );	//合并两个list，按照指定的顺序排序
void splice( iterator pos, list &lst );	//将lst指向pos位置
void splice( iterator pos, list &lst, iterator del );	//将lst中del指向pos
void splice( iterator pos, list &lst, iterator start, iterator end );//将lst区间start与end元素指向pos

L.merge(L2);	//将L2合并到L
L.merge(L2,Compare);	//将L2合并到L，指定Compare规则
L.splie(L.begin(),L2);	//将L2整个list指向L.begin()位置
L.splie(L.begin(),L2,L2.begin());	//从L2的迭代器L2.begin()开始指向L.begin()位置
L.splie(L.begin(),L2,L2.begin(),L2.end());	//将L2的迭代器区间[L2.begin(),L2.end())指向L的迭代器L.begin()位置

set容器的底层是由二叉树构成。set在插入元素时，是不允许插入重复元素的；multiset是允许插入重复元素的。set会自动排序，默认是升序。

set中不存在set s(size_type num,T val)。因为set不允许重复元素。

set<T> s; //采用模板类实现对象的默认构造形式：
set<T>s(const set& se); //拷贝函数，将s初始化为se一样
set<T>s(iterator start,iterator end)	//将s的初始化为[start,end)区间

set<int>s1;
set<int>s2(s);
set<int>s3(s.begin(),s.end());
set<int>s4 = {1,2,3,4};

可以使用set<T,Compare>指定排序规则。

iterator begin();	//返回指向第一个元素的迭代器
iterator end()		//返回末尾的迭代器
iterator rbegin()	//返回指向第一个元素的逆向迭代器
iterator rend()		//返回末尾的逆向迭代器
iterator lower_bound()	//返回指向大于（或等于）某值的第一个元素的迭代器
iterator upper_bound()	//返回大于某个值元素的迭代器

insert()； //在集合中插入元素
void erase( iterator i );	//删除i的元素
void erase( iterator start, iterator end );		//删除区间[start,end)中的元素
size_type erase( const key_type &key );		//删除指定元素值
 
s.insert(10);	//向s中插入元素10
s.erase(s.begin());	//删除元素为begin()中的元素
s.erase(s.begin(),s.end());	//删除区间[begin,end)的元素
s.erase(1);		//删除值为1的元素

unordered_set 容器，为“无序 set 容器”。即 unordered_set 容器和 set 容器很像，唯一的区别就在于 set 容器会自行对存储的数据进行排序，而 unordered_set 容器不会

	unordered_set<int>s;
	s.insert(10);
	s.insert(60);
	s.insert(30);
	s.insert(90);
	for (auto a : s) {
		cout << a<< endl;
	}
--------------------------
90
10
60
30

map 是有序键值对容器，默认是升序，它的元素的键是唯一的。用比较函数 Compare 排序键。 map 通常实现为红黑树。mutlimap是允许存储重复元素。

set中不存在map s(size_type num,T val)。因为set不允许重复元素。

map<T>m; //采用模板类实现对象的默认构造形式：
map<T>m(const map& ml); //拷贝函数，将s初始化为se一样
map<T>m(iterator start,iterator end)	//将s的初始化为[start,end)区间

map<int>m1;
map<int>m2(m);
map<int>m3(m.begin(),m.end());

可以使用map<T1,T2,Compare>指定排序规则。

iterator begin();	//返回指向第一个元素的迭代器
iterator end()		//返回末尾的迭代器
iterator rbegin()	//返回指向第一个元素的逆向迭代器
iterator rend()		//返回末尾的逆向迭代器
iterator lower_bound()	//返回指向大于（或等于）某值的第一个元素的迭代器
iterator upper_bound()	//返回大于某个值元素的迭代器

iterator insert(const pair &p)； //在集合中插入元素
void insert( input_iterator start, input_iterator end );//插入区间[start,end)元素

void erase( iterator i );	//删除i的元素
void erase( iterator start, iterator end );		//删除区间[start,end)中的元素
size_type erase( const key_type &key );		//删除指定元素值
 
 
m.insert(make_pair(1,10));	//插入pair(1,10)
m.insert(s2.begin(),s2,end());	//插入区间[begin,end)元素

m.erase(m.begin());	//删除元素为begin()中的元素
m.erase(m.begin(),m.end());	//删除区间[begin,end)的元素
m.erase(1);		//删除key为1的pair

//返回一个迭代器指向键值为key的元素，如果没找到就返回指向map尾部的迭代器
iterator find( const KEY_TYPE &key );
//还回map中键值等于key的元素的个数。map只会返回0、1，mutlimap会返回值的个数
size_type count( const KEY_TYPE &key );


map<int ,int>::iterator it=m.find(10) //在m中查找key为10的元素
int num=m.count(10);	//查找key为10的值

unordered_map与map的用法基本一直，最大的区别在于：
map的key是有序的，而unordered_map的key为无序。

#include<unordered_map>
int main() {
	unordered_map<int, int>m;
	m.insert(make_pair(1, 10));
	m.insert(make_pair(1, 20));//key相同是不会重复存储的
	m.insert(make_pair(6, 20));
	m.insert(make_pair(3, 30));
	m.insert(make_pair(9, 50));
	for (auto a : m) {
		cout << a.first << endl;
	}
	return 0;
}
-----------------------------
9
1
6
3

unordered_map与unordered_set的存储时按照散列表存储的，输出顺序与输入顺序是不一定相同的