update conclusion on c++ sequential containers.

c++ note/chp9/chp9.md

@@ -6,8 +6,7 @@ Conclusions on Sequential Containers
 + 线性容器基本操作
 	- 构造函数
 	- 拷贝/赋值/交换
-	- 插入
-	- 删除
+	- 插入与删除
 	- 访问
 	- 容量
 	- 遍历
@@ -23,7 +22,7 @@ Conclusions on Sequential Containers
 
 六个线性容器又可以分为两个阵营，向量、双端队列、 string 和 array是第一个阵营，它们在物理上都是连续存储的；列表和单向列表是第二个阵营，它们是采用动态的存储策略。存储策略的不同会导致不同容器的静态操作与动态操作具有不同的性能，因此提供的成员函数也有区别，例如 vector 并不提供在容器的前端插入或者删除元素的成员函数`push_front`和`pop_front`，因为这将需要`O(n)`的时间复杂度。在后面还将详细地阐述这一点。
 
-此外，六个容器中还有两朵奇葩，即 array 和单向列表。 array 是一个容量固定的容器，而所有其他容器都是可以动态扩容的，这决定了 array 的许多成员函数都与其他容器不同，例如不提供插入或者删除元素的接口；单向列表的设计思想是要保证最优的性能，因此单向列表削减了一些成员变量，比如单向列表不提供`size`接口，因为`O(1)`的`size`接口需要维护一个额外的 size 变量，在每次插入或者删除时都需要对该变量进行修改，这会在一定程度上降低性能。此外，由于单向列表结构的特殊性，它提供的插入和删除结构都与其他容器不同，这也会在后面详细阐述。
+此外，六个容器中还有两朵奇葩，即 array 和单向列表。 array 是一个容量固定的容器，而所有其他容器都是可以动态扩容的，这决定了 array 的许多成员函数都与其他容器不同，例如不提供插入或者删除元素的接口；单向列表的设计思想是要保证最优的性能，因此单向列表削减了一些成员变量，比如单向列表不提供`size`接口，因为`O(1)`的`size`接口需要维护一个额外的 size 变量，在每次插入或者删除时都需要对该变量进行修改，这会在一定程度上降低性能。此外，由于单向列表结构的特殊性，它提供的插入和删除接口都与其他容器不同，这也会在后面详细阐述。
 
 在实际应用中，对字符串的处理是相当常见的，为了使这部分工作变得简单，string 提供了大量额外的成员函数，本文将对其中比较常用的进行介绍。
 
@@ -141,4 +140,171 @@ swap(arr1, arr3);          //error: different size
 
 ### 插入与删除元素
 
+除 array 外的其他容器都提供了若干插入与删除元素的成员函数，而 array 由于它的定长特性，并不允许元素的插入与删除。除了单向列表以外，这些插入和删除的成员函数都有相同的接口形式，因而更加便于记忆与把握；而单向列表由于它结构上的特殊性，提供了独特的一套插入删除接口，也会在后面涉及到。
 
+> `push_back`与`pop_back`
+
+`push_back`与`pop_back`的设计思想是提供一个高效地在容器后端插入或者删除元素的接口，它的时间复杂度仅为`O(1)`。显然，单向列表并不提供这一接口，因为在单向列表后端插入或删除元素需要`O(n)`的时间复杂度。另外四个容器，即向量，双端队列以及 string以及列表都提供这两个成员函数。 
+
+需要注意的是，`push_back`与`pop_back`都没有返回值。
+
+> `push_front`与`pop_front`
+
+与`push_back`和`pop_back`类似，`push_front`与`pop_front`提供在`O(1)`时间内在容器的**前端**插入或者删除元素的接口。对于向量与 string 而言，在前端插入或者删除元素涉及到其他所有元素的移动，时间复杂度为`O(n)`，因而它们并不提供这一接口。双向队列，列表与单向列表都提供这两个成员函数。
+
+这两个函数也没有返回值。
+
+> `insert`与`erase`
+
+`insert`与`erase`是更加一般地插入或者删除元素的接口，可以在任意位置进行插入或者删除。
+
+对于`insert`而言，有若干接口形式，所有这些接口的第一个参数都是一个迭代器指示的位置信息，表示元素应该被插入的位置。需要注意的是，元素实际上是被插入到该迭代器的前面一个位置，这样当传入的参数是`c.begin()`的时候就可以将新的元素插入到容器的最前端，传入的参数时`c.end()`的时候，将新的元素插入到容器的最后端。因此，`insert`函数，实际上是`insert_before`接口。
+
++ `insert(p, t)`：将新的元素`t`插入到位置`p`的前面。
++ `insert(p, begin, end)`：将**另一容器**从迭代器`begin`到`end`的元素插入到位置`p`的前面。
++ `insert(p, n, t)`：将n个相同的元素`t`插入到位置`p`的前面。
++ `insert(p, il)`：将初始化列表`il`中的元素插入到位置`p`的前面。
+
+需要注意的是，`insert`返回指向第一个被插入元素的迭代器，如果没有元素被插入的话（比如`begin = end`，则返回第一个参数。利用`insert`的返回值可以实现反复将新的元素插入到容器的最前端
+
+```cpp
+list<string> slist;
+auto it = slist.begin();
+while(cin >> word){
+	it = slist.insert(it, word);
+}
+```
+
+上面的代码与下面这个版本完全等效
+
+```cpp
+list<string> slist;
+while(cin >> word)
+	slist.push_front(word);
+```
+
+对于`erase`而言，也提供了两种接口：
+
++ `erase(p)`：删除迭代器`p`指向的元素。
++ `erase(begin, end)`：删除迭代器`begin`到`end`范围内的所有元素。
+
+两种接口都返回指向被删除的最后一个元素的后一个位置的迭代器。除此以外，stl 还提供了`clear`成员函数，可以将所有元素清除，其效果等价于
+
+```cpp
+c.clear();//is equivalent to 
+c.erase(c.begin(), c.end());
+```
+
+> `emplace`家族
+
+除了`insert`家族以外，`emplace`家族也可以实现将元素插入到容器中的功能。与`insert`不同，`emplace`的作用并非将传入的元素拷贝到容器中，而是**构造**一个新的元素然后再插入到容器中，因此它的参数并非容器的`element_type`，而是`element_type`的构造函数的参数。`emplace`成员函数首先调用元素类型的构造函数，然后将新构造的元素插入到容器中。
+
+与`insert`相同，`emplace`家族也提供了相似的三种成员函数：
+
++ `emplace_back`：将新构造的元素插入到容器的尾部，显然单向列表并不提供该接口。
++ `emplace_front`：将新构造的元素插入到容器的首部，显然向量和 string 不提供该接口。
++ `emplace`：将新构造的元素插入到容器中的任何位置，与`insert`一样，该接口实际上是`emplace_before`。
+
+`emplace`家族的参数与`insert`家族是类似的，只不过`emplace`并不支持同时插入多个元素，它们的返回值也是一样的，即指向被插入的（第一个）元素的迭代器。
+
+> 单向列表的插入与删除
+
+此前所提及的`insert`，`erase`以及`emplace`接口，都不被单向列表实现。这是由单向列表结构的特殊性决定的。
+
+考虑一种情况，单向列表使用`insert(p, t)`插入元素`t`，为了将元素插入到迭代器`p`的前面，不得不从头遍历单向列表，找到迭代器`p`前面一个位置，然后才能调整指针完成实质的插入操作，该算法的时间复杂度为`O(n)`，而列表这种动态结构的插入与删除理论上是只需要`O(1)`的时间的，该性能显然不能令人满意。对于元素的删除也有同样的问题，因为将迭代器指示的元素释放后，还需要调整它前后的指针，为了找到被删除元素的前驱，也需要耗费`O(n)`的时间。
+
+容易看到，上面操作非常低效，实质上是因为找到某个元素的前驱需要耗费大量的时间。因此单向列表定义了特殊的插入与删除成员函数，规避了这种无意义的查找，即`insert_after`，`erase_after`以及`emplace_after`。
+
+对于`insert_after`而言，由于在插入到迭代器指示位置的后面，迭代器本身就是被插入元素的前驱，在`O(1)`时间内就能实现指针的修改。对于`erase_after`也是同样的道理，被删除元素的前驱就是传入的参数，因此可以在`O(1)`时间内完成指针的修改。
+
+单向列表提供的插入与删除接口，与`insert`，`erase`完全相同：
+
++ `insert_after(p, t)`
++ `insert_after(p, begin, end)`
++ `insert_after(p, n, t)`
++ `insert_after(p, it)`
+
+所有这些接口都返回指向被插入的**最后**一个元素的迭代器，需要注意`insert`是返回指向被插入的第一个元素的迭代器。如果没有元素被插入的话，仍然是返回`p`。
+
+`erase_after`的两个接口
+
++ `erase_after(p)`
++ `erase_after(begin, end)`：将从`begin`之后的第一个元素，到（不包括）`end`之间的元素删除。
+
+它们的返回值仍然是指向被删除元素的后一个元素的迭代器。
+
+在这几个接口的语义下，会产生一些新的问题，比如如果想要插入到单向列表的最前面，应该怎么实现呢？因此单向列表还定义了特殊的迭代器`forward_list::before_begin`以及`forward_list::cbefore_begin`，利用这两个迭代器就可以插入或者删除最前面的元素了。
+
+### 元素访问
+
+对线性容器中的元素访问有四种不同的方式：
+
++ `c.front()`：返回容器中第一个元素的**引用**；
++ `c.back()`：返回容器中最后一个元素的**引用**；
++ `c[n]`：返回容器中第 n 个元素的引用；
++ `c.at(n)`：返回容器中第 n 个元素的引用。
+
+并非所有六个容器都支持这些方式，对这一点的理解还是要基于容器本身的结构。比如单向列表并不支持 `c.back()` 这种方式，因为需要 `O(n)` 的时间才能访问到最后一个元素；同理，不支持随机访问的结构，即单向列表与列表，都不支持 `c[n]`以及`c.at(n)` 这两个接口，因为这两个接口都是基于容器内元素的物理连续性，从而可以利用偏移量 n 快速计算出元素的地址。
+
+### 容量
+
+在前面已经提到过，除了 forward_list 以外，所有其他线性容器都支持复杂度为 `O(1)` 的 `size` 接口，返回当前容器的元素个数。此外，string 还有一个 `length` 成员函数，它的作用与 `size` 是完全相同的。
+
+此外，所有线性容器都提供了 `resize(n)` 接口，使得容器含有 n 个元素。如果容器原先的元素个数大于 n，则将后面的元素删除；而如果原先的元素个数小于 n，新添加的元素被默认初始化。此外，还可以通过 `resize(n, t)` 使得新添加的元素被初始化为 `t`。
+
+对于 vector 和 string 而言，需要更加精细的容量控制。这是因为 forward_list 与 list 都是采用非连续的存储策略，插入元素时只需要分配一个元素的存储空间即可；而 vector 和 string 中元素个数一旦超过了为其预先分配的空间，则不得不重新在内存中为它开辟一个更大的空间，并且将元素依次拷贝过去，整个过程的时间复杂度为`O(n)`。
+
+因此，vector 和 string 需要同时管理 size 和 capacity 信息。两者都可以利用`c.reserve(n)`成员函数，预先在内存中开辟大小为 n （个元素）的空间，执行后有 `size = 0, capacity = n * sizeof(element_type)`，这样在插入 n 个元素前，就都不会进行自动扩容了。
+
+需要注意的是，deque 是没有这样的问题的，因为它的底层结构并非完全连续的，而是由若干连续内存区段组成的，这些段之间并非连续。因此，deque 自动扩容时，只需分配一个区段的存储空间即可，并不会进行元素的拷贝，开销相对较小。
+
+
+### 遍历
+
+遍历则相对简单。所有的线性容器（乃至关联容器）都提供了一组相同的接口：
+
++ `c.begin()`, `c.end()`。
++ `c.cbegin()`, `c.cend()`。
++ `c.rbegin()`, `c.rend()`。用于反向遍历容器的场合，显然 forward_list 并不提供该接口。
++ `c.crbegin()`, `c.crend()`。返回常量反向迭代器。
+
+## string 的额外操作
+
+stl 为 string 提供了若干额外的操作接口，在相当程度上简化了 string 的操作。
+
++ substr(begin, len)
++ extra constructor
+	- string str = "c style string";
+	- string str
++ find, rfind, find_first_of, find_last_of, find_first_not_of, find_last_not_of
+	- find(pattern, pos)
++ append, replace
++ convert
+	- to_string
+	- stod(double)
+	- stoi(integer)
++ isdigit, isalpha, isalnum, iscontrl
++ tolower(c), toupper(c)
+
+## 容器适配器
+
+栈和队列默认是使用 deque 实现的，而优先队列默认是使用 vector 来实现。三个容器适配器都支持的操作：
+
++ push()
++ emplace()
++ pop()
++ size()
++ empty
+
+获取适配器中顶端（末端）元素
+
++ stack.top()
++ queue.front(), queue.back()
++ priority_queue.top(), priority_queue.front()
+
+实际上，`algorithm` 头文件中提供了一组与堆相关的函数，我感觉比 priority_queue 灵活很多:
+
++ `make_heap(begin, end, cmp)`: 对一个 vector 进行建堆。
++ `pop_heap(begin, end, cmp)`： 将堆顶元素与最后一个元素交换，然后对新的堆顶做下滤操作。堆的容量会减少1，但是 vector 的容量不变，需要实质地调用 c.pop_back() 才能删除原先的堆顶。
++ `push_heap(begin, end, cmp)`：调用 c.push_back() 后调用该函数，对插入到尾部的元素进行上滤操作。
++ `sort_heap(begin, end, cmp)`：堆排序，默认是升序。