（第二部分）容器和算法——顺序容器

顺序容器

1.什么是顺序容器：

容器容纳特定类型对象的集合。它将单一类型元素聚集起来成为容器，然后根据位置来存储和访问这些元素，这就是顺序容器。顺序容器的元素排列次序与元素值无关，而是由元素添加到容器里的顺序决定。

标准库定义了：vector，list和deque。它们差别在于访问元素的方式，以及添加或删除元素相关操作的运行代价。lib还提供了stack，queue和priority queue适配器。

2.容器元素的初始化

<div>1)将一个容器初始化为另一个容器的副本，类型必须匹配：容器类型和元素类型都必须相同</div>

  vector<int> ivec;

  vector<int> ivec2(ivec)

2）初始化为一段元素的副本：使用迭代器时，不要求容器类型相同，元素类型可以互相转换就行

  list<string> slist(svec.begin(),sevc.end());

  vector::iterator mid=svec.bigen()+svec.end()/2;

  deque<string> front(svec.begin(),mid);

  deque<string> back(mid,sevec.end());

3)分配和初始化指定数目的元素（只适合顺序容器,关联容器不支持）

  const list<int>::size_type list_size=64;

  list<string> slist(list_size,"enh?")  //大小和元素初始化式

  也可以使用默认方式初始化

  list<int> ilist(list_size);

  extern unsigned get_word_count(const string &file_name);

  vector<string> svec(get_word_count("Chimera");

3.容器内元素的类型约束：

  1）元素类型必须支持赋值运算，（引用类型不符）

  2）元素类型的对象必须可以赋值，（IO库类型不支持）

   容器的容器：

vector< vector<string> > lines;

必须用空格隔开两个相邻的 > 操作符号,否则与>>操作符混淆

4.迭代器和迭代器范围

list容器的迭代器不支持算术运算和关系运算，它只提供自增、自减运算以及相等(不相等)运算

迭代器范围是左闭合区间：[first,last)

迭代器first和last满足以下条件：

 （1）它们指向同一个容器中的元素或超出末端的下一个位置

 （2）如果两个迭代器不相等，则对first反复做自增运算必须能到达last

5.在顺序容器中添加元素

c.push_back(t) <span style="white-space:pre"></span>在尾部添加t值，返回void类型

c.push_front(t)<span style="white-space:pre"></span>在前端添加值t，返回void类型(只适合list和deque)

c.insert(p,t)<span style="white-space:pre"></span>在p前面插入t，返回添加元素的迭代器

c.insert(p,n,t)<span style="white-space:pre"></span>在p前面插入n个t值，返回void

c.insert(p,b,e)<span style="white-space:pre"></span>在p前面插入迭代器b和e范围内的元素，返回void   

添加元素时注意：

1.添加元素可能会使迭代器失效程序必须确保迭代器在每次循环后都得到更新

2.避免存储end操作返回的的迭代器

6.容器的大小

c.size()<span style="white-space:pre"></span>返回容器c中元素的个数，类型为c::size_type

c.max_size()<span style="white-space:pre"></span>返回c可容纳的最多元素

c.empty()<span style="white-space:pre"></span>返回容器大小是否为0

c.resize(n)<span style="white-space:pre"></span>调整容器大小为n

c.resize(n,t)<span style="white-space:pre"></span>调整容器大小为n，并且元素值为t

7.访问元素

c.back()<span style="white-space:pre"></span>返回容器c的最后一个元素的引用

c.front()<span style="white-space:pre"></span>返回容器c的第一个元素的引用

c[n]<span style="white-space:pre"></span>返回下标为n的元素的引用，只适用于vector和deque

c.at(n)<span style="white-space:pre"></span>返回下标为n的元素的引用，<span style="font-family: Arial, Helvetica, sans-serif;">只适用于vector和deque</span>

<span style="font-family: Arial, Helvetica, sans-serif;">使用越界下标，或调用空容器的front或back函数，都会导致程序严重错误</span>

8.删除元素

c.erase(p)<span style="white-space:pre"> </span>删除迭代器p指向的元素，返回下一个元素的迭代器

c.erase(b,e)<span style="white-space:pre"> </span>删除迭代器b和e范围内的所有元素，返回下个迭代器

c.clear()<span style="white-space:pre"> </span>删除所有

c.pop_back()<span style="white-space:pre"> </span>删除c最后一个元素

c.pop_front()<span style="white-space:pre"> </span>删除c第一个元素

9.赋值与swap

c1=c2<span style="white-space:pre"> </span>删除c1的所有元素，把c2复制给c1（容器类型和元素类型必须相同）

c1.swap(c2)<span style="white-space:pre"> </span>交换内容<span style="font-family: Arial, Helvetica, sans-serif;">（容器类型和元素类型必须相同）:不会删除或插入任何元素，因此迭代器不会失效</span>

<span style="font-family: Arial, Helvetica, sans-serif;">c.assign(b,e)<span style="white-space:pre"> </span>重新设置c的元素，b和e必须不是c中的元素迭代器</span>

<span style="font-family: Arial, Helvetica, sans-serif;">c.assign(n,t)<span style="white-space:pre"></span>将c重置为存储n个t值得容器</span>

===========================================================================================================================================

Vector容器的自增长

vector元素以连续的方式存放，如果添加新元素没有足够的空间时，vector重新分配空间，并撤销原来的内存空间。为了使vector实现快速的内存分配，实际分配的容量要比当前所需的空间多一些。

capacity与size的区别：size指当前拥有的元素个数，而capacity则指容器在必须分配新存储空间之前可以存储的元素。

reverse操作可告诉vector应预留多少个元素的存储空间

容器选择的标准

1）在容器的中间位置添加或删除元素的代价，list

2）执行容器元素的随机访问的代价，vector和deque

容器适配器：

有三种顺序容器适配器：queue、priority_queue和stack.

适配器：是使一事物的行为类似另一事物的行为的一种机制。

1）适配器的初始化

stack<int> stk(deq);deq是deque<int>类型的容器

2)覆盖基础容器类型

默认的stack和queue都基于deque容器实现，而priority_queue则在vector容器上。可通过一下方法覆盖默认容器类型：

stack<string,vector<string> > str_stk;

stack<string,vector<string> > str_stk(svec);

栈适配器操作

s.empty()<span style="white-space:pre"></span>栈为空返回true

s.size()<span style="white-space:pre"></span>返回元素个数

s.pop()<span style="white-space:pre"></span>删除栈顶元素

s.top()<span style="white-space:pre"></span>返回栈顶元素值

s.push(item)<span style="white-space:pre"></span>在栈顶压入新元素

队列和优先队列

q.empty()<span style="white-space:pre"></span>对列空位true

q.size()<span style="white-space:pre"></span>返回大小

q.pop()<span style="white-space:pre"></span>删除队首元素

q.front()<span style="white-space:pre"></span>返回队首元素值，但不删除

q.back()<span style="white-space:pre"></span>返回队尾元素，但不删除

q.top()<span style="white-space:pre"></span>返回最高优先级的元素之，但 不删除

q.push(item)<span style="white-space:pre"></span>对于queue，在队尾压入；对于Priority_queue，基于优先级的适当位置压入