C++基础7：10大标准容器

标准容器(十大容器)
1、线性容器：向量(vector)、列表(list)、双端队列(deque)
2、适配器容器：堆栈(stack)、队列(queue)、优先队列(priority_queue)
3、关联容器：映射(map) 、多重映射(mutimap) 、集合(set) 、 多重集合(mutiset)

STL以模板为基础
容器：提供统一的访问接口,泛型化的数据结构
迭代器：通过一个抽象类型，用统一的方法访问容器中的数据

STL容器共性
1、所有的STL容器都提供支持深度拷贝的 拷贝构造函数 和 拷贝赋值运算符函数 ，但是元素类型也需要支持深度拷贝
2、容器之间能进行相等和不等的判断，容器判等的条件是：容器和元素类型都相同，容器中元素个数相同，对应元素支持 ==运算符
3、容器中保存的永远是放入对象的副本，不是对象本身
4、容器中不要放入auto_ptr（智能指针）


一、向量(vector)
1.1、基本特性
(1)用连续的地址空间保存数据元素、因此支持通过下标随机访问其中的元素
(2)动态内存管理,随着新元素的不断加入、其内存空间自动增长(不能自动收缩)
(3)通过预分配内存降低动态内存的开销
(4)支持随机位置的插入和删除，但是只有在尾端效率才比较高

1.2、空向量：
vector<int> vi   // 基本类型用0初始化， 类类型用缺省构造初始化
在指定初始大小时指定初值：
vector<元素类型> 向量对象(初始大小,初值)
vector<int> vi(10)
也可以通过其他容器进行初始化
a[4] = {12,34,56,78}
vector<int> vi(&a[0],&a[4])

1.3、迭代器：
正向迭代器：iterator
反向迭代器：reverse_iterator
常正向迭代器：const_iterator
常反向迭代器：const_reverse_iterator

1.4、常用成员函数：
value_type& front(void);
const value_type& front(void)const;
value_type& back(void);
const value_type& back(void)const;
void push_back(const value_type& val);
void pop_back(void);
iterator insert(iterator it,const value_type& val);
iterator erase(iterator it);
iterator begin(void);
const_iterator begin(void)const;
iterator end(void);
const_iterator end(void)const;
reverser_iterator rbegin(void);
const_reverser_iterator rbegin(void)const;
reverser_iterator rend(void);
const_reverser_iterator rend(void)const;

【注意】迭代器的有效期
任何可能导致容器发生变化的函数(push_back/insert/pop_back/erase/sort等)被调用，先前获得的迭代器有可能会失效，重新初始化之后才是安全的，所以调用部分函数需先清空初始化后在使用。

1.5、大小和容量
大小：实际容纳元素个数
容量：最多容纳元素个数
size_type size(void)const;  // 获取大小
void resize(size_type num,const value_type& val=value_type())  // 改变大小,可增可减,第二个参数表示新增元素的初始值,不指定的话用(0/缺省构造)
void clear();  // 清空，相当于resize(0)
bool empty()const  // 判空,空返回1
size_type reserve(size_type size)  // 改变容量，只能增，不能减， 容量以内，大小之外的元素可以访问，但是其值访问不稳定
size_type capacity()const  // 获取容量

1.6、全局泛型函数
加头文件#include <algorithm>
查找和排序
iterator find(iterator begin,iterator end,const value_type& val);
void sort(iterator begin,iterator end,less cmp)

二、列表(list)
1、列表是按照链式线性表(链表)的形式实现的
2、在列表的任意位置插入/删除都是常数时间复杂度
3、不支持下标运算,也不支持随机迭代
常用成员函数
front/push_front/pop_front
back/push_back/push_back
insert/erase
size/resize/clear/empty
begin/end/rbegin/rend
remove(const value_type& val)  // 删除所有匹配元素
void unique()  // 唯一化相邻重复元素
void splice(iterator pos,list& list)  // 将参数列表的全部元素剪切到调用列表的pos处
void splice(iterator pos,list& list,iterator del)  // 将参数列表del处的元素剪切到调用列表的pos处
void splice(iterator pos,list& list,iterator begin,iterator begin)  // 将参数列表begin开始到end之前的元素剪切到调用列表的pos处

void sort()  //默认按从小到大牌
void sort(less cmp)  // 排序
void merge(list& list);//通过“<”比较
void merge(list& list,less cmp);


三、双端队列(deque)
1、双端队列的物理结构几乎和向量一模一样,唯一的区别是双端队列的头尾都是开放的,都可以压入和弹出数据
2、接口和与向量相比增加了pop_front/push_front函数,去掉了capacity/reserve函数
3、性能上双端队列比向量略差，内存消耗更多,对元素的访问也比向量略长
4、空间的对称性决定了双端队列在首尾做相同的操作的时间复杂度也是对称的


四、堆栈(stack)
后进先出
push------>push_back
pop------->pop_back
top-------->back
size------->size
empty---->empty
定义：
stack<元素类型,底层容器类型> 堆栈对象
stack<int,vector<int>> si;
缺省底层容器类型为deque 


五、队列(queue)
先进先出
push------->push_back
pop-------->pop_front
front ------->front
back------->back
size-------->size
empty----->empty
队列不能用向量实现
缺省底层容器类型为deque 


六、优先队列(priority_queue)
优者先出
push   入队
pop    出队
top    队首
priority_queue<元素类型,底层容器类型> 优先队列对象， 通过元素类型的"<"比大小，以大者为优
priority_queue<元素类型,底层容器类型,比较器类型> 优先队列对象， 通过比较器比大小,以大者为优
底层容器可以使用vector或deque(缺省)


七、映射(map)
1、映射是一个key-value对的序列，其中每个key都是唯一的
2、存储方面，映射采用的是平衡有序二叉树的结构
3、key的大小比较可以通过器类型的“<”运算符或者比较器完成
4、映射中的数据元素是以pair为单位进行存储和访问，pair有2个成员变量， 一个叫first对应映射中的key，一个叫second对应映射中的value pair<iterator,bool> insert(const pair<key_type,value_type>& pair)
5、支持以key为参数的下标运算,获取/添加(修改)与该key对应的value


八、多重映射(mutimap)
1/允许key重复，一个key对应多个value
A-100
A-200
A-300
2、不支持下标运算
3、常用成员函数
iterator lower_bound(const key_type& key)   // 获取匹配下限,失败返回终止迭代器

iterator upper_bound(const key_type& key)  //获取匹配上限,失败返回终止迭代器

pair<iterator,iterator> equal_range(const key_type& key)  //同时返回匹配上下限

A-100
B-200 ---> lower_bound(’B‘);
B-300
B-400
C-500 ---> upper_bound(’B‘);


九、集合(set)

没有value的映射

十、多重集合(mutiset)
没有value的多重映射