容器deque
C++ STL容器deque和vector很類似，也是采用動態數組來管理元素。
使用deque之前需包含頭文件：
#include <deque>
它是定義在命名空間std內的一個class template：
template
class _Ax = allocator<_Ty> >
class deque;
第一個template參數用來表示元素型別，第二個可有可無，指定內存模型。一般使用默認的內存模型。
與vector不同的是deque的動態數組首尾都開放，因此能夠在首尾進行快速地插入和刪除操作。
deque是一種分段連續的容器，特點是雙向開口，可以認為它是一段連續的內存空間，不僅可以向前方增加內存空間，也可以向后方增加內存空間。
在實際內存中實現雙向擴充是比較復雜的事情，那么deque中是如何實現的呢？deque通過一個控制器來串聯一系列的緩沖器（buffer），從而達到邏輯上的連續效果。
deque的內存管理示意圖，如下圖所示：
deque是通過一個vector在維護自身的控制器，在控制器中存儲的是指向buffer的指針，因此我們需要用一個指向指針的指針來指向這個vector的地址。
deque能在邏輯上實現內存連續，最關鍵的是iterator在起作用。迭代器運行到邊界的時候，都需要檢測是否到邊界，然后通過回到控制buffer的那個vector來管理邊界的buffer了。在iterator中，cur、first、last和node分別指向了用戶使用時的當前的數據，first指向了buffer的第一塊空間，last指向了buffer之后那個不在buffer中的空間，而node指向了控制buffer的指針序列中的實際位置
deque的源代碼如下所示（參考課程PPT）：
deque iterator的源代碼如下所示：
deuqe的插入問題：
元素插入的時候因為是按順序排列，如果插入元素不在兩頭在中間，會改變其他元素的位置，如果插入點距離前段比較近，那么移動前段比較合適，效率較高；
如果插入點距離后端比較近，那么將插入點之后的元素向后移動比較快。
deque insert函數的源代碼如下：
iterator insert(iterator postion, const value_type& x){
if(postion.cur == start.cur) //如果安插點是deque的最前端
{
push_front(x); //直接使用push_front
return start;
}
else if(postion.cur == finish.cur) //如果安插點是deque的最末位
{
push_back(x); //直接交給push_back
iterator tmp = finish;
--tmp;
return tmp;
}
else
{
return insert_aux(postion, x);
}
}
template
typename deque::iterator_deque:: itert_aux(iterator pos, const value_type& x){
difference_type index = pos - start; //安插點之前的元素個數
value_type x_copy = x;
if(index < size() / 2){ //如果安插點之前的元素較少
push_front(front()); //在最前端加入第一個元素同值的元素
.......
copy(front2, pos1, front1); //元素搬移
}
else { //安插點之后的元素較少
push_back(back());//在尾端加入最末元素同值的元素
......
copy_backward(pos, back2, back1);//元素搬移
}
*pos = x_copy;//在安插點上設定新值
return pos;
}
deque如何模擬連續空間，全是的確iterators的功勞
具體代碼如下：
reference operator[](size_type n)
{
return start[difference_type(n)];
}
reference front()
{
return *start;
}
reference back()
{
iterator tmp = finish;
--tmp;
return *tmp;
}
size_type size() const
{
return finish - start;
}
bool empty() const
{
return finish == start;
}
reference operator* () const
{
return *cur;
}
pointer operator->() const
{
return &(operator*());
}
//兩個iterator之間的距離相當于
//（1）兩個iterator之間的buffer的總長度+
//（2）itr至buffer末尾的長度+
//（3）x至buffer開頭的長度
difference_type
operator- (const self& x) const
{
return difference_type(buffer_size()) * (node - x.node - 1) + (cur - first) + (x.last - x.cur);
//buffer size * 首尾buffer之間的buffer之間的數量 + 末尾（當前）buffer的元素量 + 起始buffer的元素量
}
self& operator++()
{
++cur; //切換至下一個元素
if(cur == last){ //如果抵達緩沖區的末尾
set_node(node + 1); //就跳至下一個節點（緩沖區）的起點
cur = first;
}
return *this;
}
self operator++(int)
{
self tmp = *this;
++*this;
return tmp;
}
self& operator--()
{
if(cur == first){ //如果目前在緩沖區開頭，
set_node(node - 1); //就跳至前一節點（緩沖區）的最末端。
cur = last;
}
--cur; //往前移動一個元素（最末元素）
return *this;
}
self operator--(int)
{
self tmp = *this;
--*this;
return tmp;
}
void set_node(map_pointer new_node)
{
node = new_node;
first = *new_node;
last = first + difference_type(buffer_size));
}
self& operator+=(difference_type n ){
difference_type offset = n + (cur - first);
if(offset >= 0 && offset < difference_type(buffer_size())
//目標位置在同一級緩存區
cur += n;
else{
//目標位置不在同一級緩存區內
difference_type node_offset = offset > 0? offset / difference_type(buffer_size()): -difference_type((-offset - 1) / buffer_size;
//切換至正確的的緩存區
set_node(node + node_offset);
cur = first + (offset - node_offset * difference_type(buffser_size());
}
return *this;
}
operator+(difference_type n) const
{
self tmp = *this;
return tmp += n;
}
self& operator-=(difference_type n)
{
return *this += - n;
}
self operator-(difference_type n)
{
self tmp = *this;
return tmp -= n;
}
reference operator[] (difference_type n)const
{
return *(*this + n);
}
GNU 4.9版本中實現的dequeUML圖，如下圖所示：
衍生
deque和vector的不同之處：
- 兩端都能夠快速插入和刪除元素。vector只能在尾端進行。
- deque的元素存取和迭代器操作會稍微慢一些。因為deque的內部結構會多一個間接過程。
- 迭代器是特殊的智能指針，而不是一般指針。它需要在不同的區塊之間跳轉。
- deque可以包含更多的元素，其max_size可能更大。因為不止使用一塊內存。
- 不支持對容量和內存分配時機的控制。
注意：在除了首尾兩端的其他地方插入和刪除元素，都將會導致指向deque元素的任何pointers、references、iterators失效。不過，deque的內存重分配優于vector。因為其內部結構顯示不需要復制所有元素。 - deque的內存區塊不再被使用時，會被釋放。deque的內存大小是可縮減的。不過，是不是這么做以及怎么做由實作版本定義。
deque和vector相似的特性：
- 在中間部分插入和刪除元素相對較慢，因為所有元素都要被移動。
- 迭代器屬于隨即存取迭代器。
最好采用deque的情形：
- 需要在兩端插入和刪除元素。
- 無需引用容器內的元素。
3.要求容器釋放不再使用的元素。
容器 queue
queue模版類的定義在頭文件中
queue與stack模版非常類似，queue模版也需要定義兩個模版參數，一個是元素類型，一個是容器類型，元素類型是必要的，容器類型是可選的，默認為dqueue類型。
定義queue對象的示例代碼如下：
queueq1;
queueq2;
queue的基本操作有：
- 入隊：如q.push(x):將x元素接到隊列的末端；
- 出隊：如q.pop() 彈出隊列的第一個元素，并不會返回元素的值；
- 訪問隊首元素：如q.front()
- 訪問隊尾元素，如q.back();
- 訪問隊中的元素個數，如q.size();
優先隊列
在頭文件中，還定義了一個非常有用的模版類priority_queue(優先隊列），優先隊列與隊列的差別在于優先隊列不是按照入隊的順序出隊，而是按照隊列中元素的優先權順序出隊（默認為大者優先，也可以通過指定算子來指定自己的優先順序）。
priority_queue模版類有三個模版參數，元素類型，容器類型，比較算子。其中后兩個都可以省略，默認容器為vector，默認算子為less，即小的往前排，大的往后排（出隊時序列尾的元素出隊）。
定義priority_queue對象的示例代碼如下：
priority_queueq1;
priority_queue >q2;
priority_queue，greater >q3;//定義小的先出隊
priority_queue的基本操作均與queue相同
初學者在使用priority_queue時，最困難的可能就是如何定義比較算子了。如果是基本數據類型，或已定義了比較運算符的類，可以直接用STL的less算子和greater算子——默認為使用less算子，即小的往前排，大的先出隊。如果要定義自己的比較算子，方法有多種，這里介紹其中的一種：重載比較運算符。優先隊列試圖將兩個元素x和y代入比較運算符(對less算子，調用xy)，若結果為真，則x排在y前面，y將先于x出隊，反之，則將y排在x前面，x將先出隊。
容器queue是以deque為底層結構實現的，具體代碼如下：
template >
class queue
{
............
public:
typedef typename Sequence::value_type value_type
typedef typename Sequence::size_type size_type
typedef typename Sequence::reference reference;
typedef typename Sequence::const_reference const_reference;
protected:
Sequence c; //底層容器
public:
bool empty() const{return c.empty();}
size_type size() const{return c.size();}
reference front() const {return c.front();}
const_reference front() const{ return c.front();}
reference back(){return c.back(); }
const_reference back() const {return c.back();}
void push (const value_type& x){ c.push_back(); }
void pop(){c.pop.front();}
}
容器 stack
容器stack也是以deque為底層結構實現的，需要注意的是queue和stack都不允許遍歷，也不提供iterator，具體代碼如下：
template >
class stack
{
............
public:
typedef typename Sequence::value_type value_type
typedef typename Sequence::size_type size_type
typedef typename Sequence::reference reference;
typedef typename Sequence::const_reference const_reference;
protected:
Sequence c; //底層容器
public:
bool empty() const{return c.empty();}
size_type size() const{return c.size();}
reference top() const {return c.back();}
const_reference top() const{ return c.back();}
void push (const value_type& x){ c.push_back(); }
void pop(){c.pop.back();}
}
容器 rb_tree
Red-Black tree（紅黑樹）是平衡二元搜尋樹（balanced Binary search tree）中常被使用的一種。
平衡二元搜尋樹的特征：排列規律，有利于search和insert，并保持適度平衡，無任何節點過深。
紅黑樹的實現代碼：
容器 set，multiset
需要包含頭文件
#include <set>
set和multiset都是定義在std空間里的類模板：
template
class _Pr = less<_Kty>,
class _Alloc = allocator<_Kty> >
class set
template
class _Pr = less<_Kty>,
class _Alloc = allocator<_Kty> >
class multiset
只要是可復賦值、可拷貝、可以根據某個排序準則進行比較的型別都可以成為它們的元素。第二個參數用來定義排序準則。缺省準則less是一個仿函數，以operator<對元素進行比較。
所謂排序準則，必須定義strict weak ordering，其意義如下：
- 必須使反對稱的。
對operator<而言，如果x - 必須使可傳遞的。
對operator<而言，如果x - 必須是非自反的。
對operator<而言，x
因為上面的這些特性，排序準則可以用于相等性檢驗，就是說，如果兩個元素都不小于對方，則它們相等。
set和multiset的功能
和所有關聯式容器類似，通常使用平衡二叉樹完成。事實上，set和multiset通常以紅黑樹實作而成。
自動排序的優點是使得搜尋元素時具有良好的性能，具有對數時間復雜度。但是造成的一個缺點就是：
不能直接改變元素值。因為這樣會打亂原有的順序。
改變元素值的方法是：先刪除舊元素，再插入新元素。
存取元素只能通過迭代器，從迭代器的角度看，元素值是常數。
容器set的實現代碼：
template , class Alloc = alloc>
class set{
public:
//typedefs:
typedef Key key_type;
typedef Key value_type;
typedef Compare key_compare;
typedef Compare value_compare;
private:
typedef rb_tree rep_type;
rep_type t;
public:
typedef typename rep_type::const_iterator iterator;
...
//set的所有操作，都調用底層rb_tree的函數，從這點看來，set實際應該為container adapter
}
容器multiset的實現代碼如下：
容器 map和multimap
map的實現代碼如下：
multimap實現代碼如下：
容器map獨特的operator[]
衍生：
- map和multimap容器跟set和multiset容器非常相似，包括外部接口和內部結構上。不同之處就是set和multiset容器是以單個對象為管理元素，而map和multimap容器是以pair為管理元素。map和multimap容器中元素同時是自動排序，它們排序的依據是各個元素的key值。
- map和multimap容器在內部結構上通常也采用平衡二叉樹(balanced binary tree)，擁有跟set和multiset一樣的能力和操作。不同之處就是元素形式上，另外map和multimap容器可以作為關聯數組使用。
- 在map或者multimap容器中查找特定值的元素，除了傳統的遍歷元素查找外，還可以使用通用算法來查找，但要自己設計函數對象
