STL list

1.list概述

list每插入或删除一个元素就申请或释放一个元素空间。

2. list的结点

template <class T>
struct __list_node {
  typedef void* void_pointer;
  void_pointer next;    //后继
  void_pointer prev;    //前驱
  T data;               //数据
};

list的迭代器

list 不再能够像 vector 一样以原生指标做为迭代器，因为其节点不保证在储存空间中连续存在。list 迭代器必须有能力指向 list 的节点，并有能力做正确的递增、递减、取值、成员存取等动作。因此list 迭代器正确的递增、递减、取值、成员取用记为：递增时指向下一个节点，递减时指向上一个节点，取值时取的是节点的资料值，成员取用时取用的是节点的成员。

list是Bidirection Iterator.
list的迭代器设计如下

template<class T, class Ref, class Ptr>
struct __list_iterator {
  typedef __list_iterator<T, T&, T*>             iterator;
  typedef __list_iterator<T, const T&, const T*> const_iterator;
  typedef __list_iterator<T, Ref, Ptr>           self;

  typedef bidirectional_iterator_tag iterator_category;
  typedef T value_type;
  typedef Ptr pointer;
  typedef Ref reference;
  typedef __list_node<T>* link_type;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  link_type node;       //迭代器有一个指针，指向list的结点
//以下为构造函数
  __list_iterator(link_type x) : node(x) {}
  __list_iterator() {}
  __list_iterator(const iterator& x) : node(x.node) {}

  bool operator==(const self& x) const { return node == x.node; }
  bool operator!=(const self& x) const { return node != x.node; }
  reference operator*() const { return (*node).data; }//取指，得到data

#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->() const { return &(operator*()); }//取迭代器的成员
#endif /* __SGI_STL_NO_ARROW_OPERATOR */

  self& operator++() { //自加，前进一个节点
    node = (link_type)((*node).next);
    return *this;
  }
  self operator++(int) { //iter++,返回iter,然后再自加
    self tmp = *this;
    ++*this;
    return tmp;
  }
  self& operator--() { 
    node = (link_type)((*node).prev);
    return *this;
  }
  self operator--(int) { 
    self tmp = *this;
    --*this;
    return tmp;
  }
};

4.list的数据结构

list不仅是一个双向链表，而且是一个环状双向链表，只用一个指针便可遍历整个链表。
list自己有一个空的node,使其符合STL对于”前闭后开”的要求。

5.list的构造和内存管理

初始化时的list如下如：

6.list的元素操作

转移操作：

splice操作

//把list x放到position之前
  void splice(iterator position, list& x) {
    if (!x.empty()) 
      transfer(position, x.begin(), x.end());
  }
//将 i 所指元素接合于 position 所指位置之前。position 和 i 可指向同㆒个 list
  void splice(iterator position, list&, iterator i) {
    iterator j = i;
    ++j;
    if (position == i || position == j) return;
    transfer(position, i, j);
  }
//将 [first,last) 内的所有元素接合于 position 所指位置之前。
// position 和[first,last)可指向同㆒个 list，
// 但 position 不能位于[first,last)之内。
  void splice(iterator position, list&, iterator first, iterator last) {
    if (first != last) 
      transfer(position, first, last);
  }

有了transfer()，merge(),reverse(),sort()都可以实现了。

//合并操作
template <class T, class Alloc>
void list<T, Alloc>::merge(list<T, Alloc>& x) {
  iterator first1 = begin();
  iterator last1 = end();
  iterator first2 = x.begin();
  iterator last2 = x.end();
  while (first1 != last1 && first2 != last2)
    if (*first2 < *first1) {//first2较小，移到first之前
      iterator next = first2;
      transfer(first1, first2, ++next);
      first2 = next;
    }
    else
      ++first1;//否则first1往后移
  if (first2 != last2) transfer(last1, first2, last2);//最后还有剩余元素，直接加上
}

//翻转
template <class T, class Alloc>
void list<T, Alloc>::reverse() {
  if (node->next == node || link_type(node->next)->next == node) return;
  iterator first = begin();
  ++first;
  while (first != end()) {//把后面的元素全部插入到首元素上
    iterator old = first;
    ++first;
    transfer(begin(), old, first);
  }
}    

//排序
template <class T, class Alloc>
void list<T, Alloc>::sort() {
  if (node->next == node || link_type(node->next)->next == node) return;
  list<T, Alloc> carry;
  list<T, Alloc> counter[64];   //辅助数组
  int fill = 0;     //堆栈的层次
  while (!empty()) {
    carry.splice(carry.begin(), *this, begin());    //取出一个元素放入carry
    int i = 0;
    while(i < fill && !counter[i].empty()) {
      counter[i].merge(carry);      //merge之后，carry为空
      carry.swap(counter[i++]);     //交换之后，counter[i]为空，carry为合并的
    }
    carry.swap(counter[i]);         
    if (i == fill) ++fill;      //层次不够用
  } 

  for (int i = 1; i < fill; ++i) 
    counter[i].merge(counter[i-1]);//全部放到counter[fill-1]中去
  swap(counter[fill-1]);
}

以下内容参考 https://sosohu.github.io/algorithm/2015/04/14/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F%E7%9A%84%E8%BF%AD%E4%BB%A3%E5%86%99%E6%B3%95.html
总体上来说，算法的思想就是准备64个槽(counter[i])，编号为0,1,…,63,分别表示已经排序长为1,2,…的链表．一开始这64个槽为空.

1. 如果待排序链表还有未被取出的元素则取出下一个元素，否则转到3
2. 将这个元素先和0号槽合并，如果此时0号槽为空则，将合并后结果放入0号槽;如果不为空那么合并后长度变为2,则清空0号槽，继续和1号槽合并，依次类推一直合并到i号槽，且i号槽为空，则将合并结果放入i号槽．转到1.
3. 将这64个槽从低到高依次合并，得到最终的结果.

下面以链表数据4，2，1，5，6，9，7，8，10为例分析这个迭代版的代码过程

在while循环里面每次都是从原链表里取出一个节点，然后往counter数组里面归并，fill值表明目前counter数组中存有数据的最大的那个数组标号+1,比如说，我们首先取出４，此时fill = 0, 直接就把４放在counter[0]链表上，fill变为1，然后取出1，就拿2与counter[0]进行merge，得到结果放到count[1],fill变为2，此时counter数组的情况是counter[0]为空，counter[1]存放2，4，再加入1时候直接放到counter[0], 再加入5时候，1与5merge，得到1，5再继续向上和couter[1]中的2,4,merge得到1，2，4，5，如果此时counter[2]不为空，那么继续merge，这里为空则1，2，4，5存到counter[2],于是就这样一步步的向上merge，每次merge链表长度都是加倍

最终取完所有数据之后，counter数组里面的数据需要最终整合一下，代码中最后一个for循环就是不断的把couter中的内容向上merge，最终形成最后的结果

这里其实也就是形成了一颗归并树，时间复杂度依然是O(nlgn)
时间复杂度O(nlgn),空间复杂度O(1),因为是链表所以空间复杂度才会是O(1),换成连续存储的容器就不行了.