STL序列式容器学习总结
参考资料：《STL源码剖析》
参考网址：
Vector: http://www.cnblogs.com/zhonghuasong/p/5975979.html
List: http://www.cnblogs.com/scandy-yuan/archive/2013/01/08/2851324.html
Deque: http://blog.csdn.net/longshengguoji/article/details/8519812
1.Array
array是C++提供的序列式容器，是静态连续空间，一旦确定就不能改变。C++11中引入了array容器，array是序列容器的一种。array在栈上分配连续的内存来储存元素，并且array的大小是不可以改变的，这也就是说，可以修改array中元素的值，但不能向array中插入和删除元素。避免了动态数组new和delete的使用，内存自动管理。
l 声明：array<int>arr1={ };
array<int,n>arr2{ };
l 访问：arr1[1] / arr1.at[1];
l 当前容量：arr1.size();
l 最大容量：arr1.max_size();
l 迭代器开始处：arr1.begin();
l 迭代器结束处：arr1.end();
l 访问第一个元素：arr1.front();
l 访问最后一个元素：arr1.back();
l 是否为空：arr1.empty( );
l 赋值：arr1.fill(n);
l 交换元素：arr1[i].swap()；
2.Vector
Vector是动态的连续线性空间，随着元素加入，会自动扩充空间（即capacity以2倍速度扩充）。对vector的任何操作，一旦引起空间重新配置，志向原vector的所有迭代器就都失效了。
l 声明：vector<int> vec; //声明一个int型向量
vector<int> vec(5); //声明一个初始大小为5的int向量
vector<int> vec(10, 1); //声明一个初始大小为10且值都是1的向量
int arr[5] = {1, 2, 3, 4, 5};
vector<int> vec(arr, arr + 5); //将arr数组的元素用于初始化vec向量
vector<int> vec(&arr[1], &arr[4]); //将arr[1]~arr[4]范围内的元素作为vec的初始值
l 向量大小： vec.size();
l 向量最大容量： vec.max_size();
l 更改向量大小： vec.resize();
l 向量真实大小： vec.capacity();
l 向量判空： vec.empty();
l 减少向量大小到满足元素所占存储空间的大小： vec.shrink_to_fit();
l 多个元素赋值： vec.assign(); //类似于初始化时用数组进行赋值
l 末尾添加元素： vec.push_back();
l 末尾删除元素： vec.pop_back();
l 任意位置插入元素： vec.insert();
l 任意位置删除元素： vec.erase();
l 交换两个向量的元素： vec.swap();
l 开始指针：vec.begin();
l 末尾指针：vec.end(); //指向最后一个元素的下一个位置
l 指向常量的开始指针： vec.cbegin(); //意思就是不能通过这个指针来修改所指的内容，但还是可以通过其他方式修改的，而且指针也是可以移动的。
l 下标访问： vec[1]; //并不会检查是否越界
l at方法访问： vec.at(1); //以上两者的区别就是at会检查是否越界，是则抛出out of range异常
l 访问第一个元素： vec.front();
l 访问最后一个元素： vec.back();
l 返回一个指针： int* p = vec.data(); //可行的原因在于vector在内存中就是一个连续存储的数组，所以可以返回一个指针指向这个数组。这是是C++11的特性。
l
l 指向常量的末尾指针： vec.cend();
l 清空向量元素： vec.clear();
3.list
list容器是一个环状双向链表,可以高效地进行插入删除元素，节点不保证在储存空间连续存在。List的插入和结合操作都不会造成原有的迭代器失效，符合STL规范的“前闭后开”区间，环状链表的尾端有一个空白节点。
l 声明函数： list<int> c0; //空链表
list<int> c1(3); //建一个含三个默认值是0的元素的链表
list<int> c2(5,2); //建一个含五个元素的链表，值都是2
list<int> c4(c2); //建一个c2的copy链表
list<int> c5(c1.begin(),c1.end()); ./c5含c1一个区域的元素[_First, _Last)。
l 指向链表第一个元素的迭代器：c.begin()；
l 指向链表最后一个元素之后的迭代器：c.end() ；
l c.rbegin()：返回逆向链表的第一个元素,即c链表的最后一个数据。
l c.rend() ：返回逆向链表的最后一个元素的下一个位置,即c链表的第一个数据再往前的位置。
l c.assign(n,num) ：将n个num拷贝赋值给链表c。
l c.assign(beg,end) ：将[beg,end)区间的元素拷贝赋值给链表c。
l c.front()：返回链表c的第一个元素。
l c.back()：返回链表c的最后一个元素。
l c.empty()：判断链表是否为空；
l c.size()：返回链表c中实际元素的个数；
l c.max_size()：返回链表c可能容纳的最大元素数量；
l c.clear():清除链表c中的所有元素。
l c.insert(pos,num):在pos位置插入元素num。
l c.insert(pos,n,num):在pos位置插入n个元素num。
l c.insert(pos,beg,end):在pos位置插入区间为[beg,end)的元素。
l c.erase(pos):删除pos位置的元素。
l c.push_back(num):在末尾增加一个元素。
l c.pop_back():删除末尾的元素。
l c.push_front(num):在开始位置增加一个元素。
l c.pop_front():删除第一个元素。
l c.resize(n) :从新定义链表的长度,超出原始长度部分用0代替,小于原始部分删除。
l c.resize(n,num):从新定义链表的长度,超出原始长度部分用num代替。
l c1.swap(c2); 将c1和c2交换。
l swap(c1,c2); 同上。
l c1.merge(c2) 合并2个有序的链表并使之有序,从新放到c1里,释放c2。
l c1.merge(c2,comp) 合并2个有序的链表并使之按照自定义规则排序之后从新放到c1中,释放c2。
l c1.splice(c1.beg,c2) 将c2连接在c1的beg位置,释放c2
l c1.splice(c1.beg,c2,c2.beg) 将c2的beg位置的元素连接到c1的beg位置，并且在c2中施放掉beg位置的元素
l c.remove(num):删除链表中匹配num的元素。
l c. reverse():反转链表
l c.sort():将链表排序，默认升序
l c.sort(comp):自定义回调函数实现自定义排序
l c.unique():容器内相邻元素若有重复的，则仅保留一个.
4.deque
deque容器为一个给定类型的元素进行线性处理，支持高效插入和删除容器的头部元素，是一种双向开口的连续线性空间。Deque没有容量的概念，因为它动态的以分段空间组合而成。所有的deque块使用一个Map块进行管理，每个Map数据项记录各个deque块的首地址。Map是deque的中心部件，将先于deque块，依照deque元素的个数计算出deque块数，作为Map块的数据项数，创建出Map块。以后，每创建一个deque块，都将deque块的首地址存入Map的相应数据项中。
Deque的内部实现原理见：http://www.cnblogs.com/alionxd/articles/3028711.html
l deque():创建一个空deque
l deque(int nSize):创建一个deque,元素个数为nSize
l deque(int nSize,const T& t):创建一个deque,元素个数为nSize,且值均为t
l deque(const deque &):复制构造函数
l void push_front(const T& x):双端队列头部增加一个元素X
l void push_back(const T& x):双端队列尾部增加一个元素x
l iterator insert(iterator it,const T& x):双端队列中某一元素前增加一个元素x
l void insert(iterator it,int n,const T& x):双端队列中某一元素前增加n个相同的元素x
l void insert(iterator it,const_iterator first,const_iteratorlast):双端队列中某一元素前插入另一个相同类型向量的[forst,last)间的数据
l Iterator erase(iterator it):删除双端队列中的某一个元素
l Iterator erase(iterator first,iterator last):删除双端队列中[first,last）中的元素
l void pop_front():删除双端队列中最前一个元素
l void pop_back():删除双端队列中最后一个元素
l void clear():清空双端队列中最后一个元素
l reference at(int pos):返回pos位置元素的引用
l reference front():返回手元素的引用
l reference back():返回尾元素的引用
l iterator begin():返回向量头指针，指向第一个元素
l iterator end():返回指向向量中最后一个元素下一个元素的指针（不包含在向量中）
l reverse_iterator rbegin():反向迭代器，指向最后一个元素
l reverse_iterator rend():反向迭代器，指向第一个元素的前一个元素
l bool empty() const:向量是否为空，若true,则向量中无元素
l Int size() const:返回向量中元素的个数
l int max_size() const:返回最大可允许的双端对了元素数量值
l void swap(deque&):交换两个同类型向量的数据
l void assign(int n,const T& x):向量中第n个元素的值设置为x
5.stack
stack是一种先进后出（FILO）的数据结构，只能是从栈顶压入元素或者从栈顶取出元素，缺省情况下以deque作为底层数据结构（也可以设置list为底层数据结构），不允许有遍历行为，也没有迭代器。
l 声明：stack<T>s;
stack<T,list<T>>s
l s.push(x):将元素x压栈
l s.pop():删除栈顶元素
l s.top():返回栈顶元素
l s.empty():判断栈是否为空；
l s.size():返回栈中元素的个数
6.queue
l queue是一种先进先出（FIFO）的数据结构，缺省情况下以deque作为底层数据结构（也可以设置list为底层数据结构），不允许有遍历行为，也没有迭代器。只能从最低端加入最顶端取出元素。
l 声明：queue<T>q;
l queue<T ,list<T>>q;
l q.push(x) 将x压入队列的末端
l q.pop() 弹出队列的第一个元素(队顶元素)，注意此函数并不返回任何值
l q.front() 返回第一个元素(队顶元素)
l q.back() 返回最后被压入的元素(队尾元素)
l q.empty() 当队列为空时，返回true
l q.size() 返回队列的长度
7.heap
heap并不属于STL容器组建，heap分为max_heap和min_heap，默认为max_heap. Heap是一个类属算法，包含在algorithm头文件中
l make_heap(first_pointer,end_pointer): male_heap就是构造一棵树，使得每个父结点均大于等于其子女结点
l pop_heap(first_pointer,end_pointer):pop_heap不是删除某个元素而是把第一个和最后一个元素对调后[first,end-1]进行构树，最后一个不进行构树
l push_heap():push_heap()假设由[first,last-1)是一个有效的堆，然后，再把堆中的新元素加
进来，做成一个堆。
l sort_heap(first_pointer,end_pointer):把树的结点的权值进行排序
8.priority queue
l 声明：priority_queue<int> p;
l q.push (x);.将x接到队列的末端。
l q.top ();.访问队首元素
l q.pop ();.删除队首元素
l q.front();.访问队首元素 最早被压入队列的元素。
l q.back();.访问队尾元素 最后被压入队列的元素。
l q.size();.访问队列中的元素个数
l q.empty ();.判断是否为空 当队列空时，返回true。
