chapter4 序列式容器：list

1 与vector的区别

1. 相较于vector的连续线性空间，list要相对复杂许多。它的好处是每次插入或删除一个元素，就配置或释放一个元素空间。因此，list对于空间的运用有绝对的精准。

2. 对于任何位置的元素插入或元素删除，list永远是常数时间。

3. list无法像vector一样以普通指针作为迭代器，因为其节点不保证在储存空间中连续存在。

4. 对于list而言，插入操作和接合操作都不会造成原有的list迭代器失效。在vector中不成立，因为vector的插入操作可能造成记忆体重新配置。

2 list的节点

//双向链表
template <class T>
struct __list_node {
    typedef void* void_pointer;
    void_pointer prev;
    void_pointer next;
    T data;
}

3 list的迭代器

1. list迭代器不是普通指针，它必须有能力指向list的节点，并有能力进行“正确的递增、递减、取值、成员存取等操作”。
2. 由于STL list是一个双向链表（double linked-list），迭代器必须具备前移、后移的能力，所以list提供的是Bidirectional Iterators。
3. 对于list而言，插入操作和接合操作都不会造成原有的list迭代器失效（见上述）。

3.1 list迭代器的设计

template <class T, class Ref, class Ptr>
struct __list_iterator {
    typedef __list_iterator<T, T&, T*> 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的节点
    
    //constructor
    __lint_iterator(link_type x) : node(x) {}
	__lint_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; }
    //以下是对迭代器取值(dereference)，取的是节点的数据值
    reference operator*() const { return (*node).data; }
    
    //以下是迭代器的成员存取(member access)运算子的标准做法
    pointer operator->() const { return &(operator*()); }
    
    //对迭代器累加1，就是前进一个节点
    self& operator++() {	//前置将对象本身作为左值返回
        node = (link_type)((*node).next);
        return *this;
    }
    self operator++(int) {
        self tmp = *this;
        ++*this;
        return tmp;
    }
    
    //对迭代器递减1，就是后退一个节点
    self& operator--() {
        node = (link_type)((*node).prev);
        return *this;
    }
    self operator--(int) {
        self tmp = *this;
        --*this;
        return tmp;
    }
}

4 list的数据结构

SGI list不仅是一个双向链表，而且还是一个环状双向链表，所以它只需一个指针，便可以完整表现整个链表：

template <class T, class Alloc = alloc> //缺省使用alloc为配置器
class list {
protected:
    typedef __list_node<T> list_node;
public:
    typedef list_node* link_type;
    
protected:
    link_type node;  //只要一个指针，便可完整表示整个环状双向链表
...
}

如果让指针node指向刻意置于尾端的一个空白节点，node便能符和STL对于“前闭后开”区间的要求，称为last迭代器。

iterator begin() { return (link_type)((*node).next); }
iterator end() { return node; }
bool empty() const { return node->next == node; }
size_type size() const {
    size_type result = 0;
    distance(begin(), end(), result);
    return result;
}
//取头结点的内容(元素值)
reference front() { return *begin(); }
//取尾结点的内容(元素值)
reference back() { return *(--end()); }

5 list的构造与内存管理

list缺省使用alloc作为空间配置器，并据此另外定义了一个list_node_allocator,为的是更方便地以节点大小为配置单位：

template <class T, class Alloc = alloc>
class list {
protected:
    typedef __list_node<T> list_node;
    //专属之空间配置器，每次配置一个节点大小
    typedef simple_alloc<list_node, Alloc> list_node_allocator;
...
}

于是，list_node_allocator表示配置n个节点空间。以下四个函数，分别用来配置、释放、构造和销毁一个节点：

protected:
	//配置一个节点并传回
	link_type get_node() { return list_node_allocator::allocate(); }
    //释放一个节点
    void put_node(link_type p) { lint_node_allocator::deallocate(p); }

    //产生（配置并构造）一个节点，带有元素值
    link_type create_node(const T& x) {
    	link_type p = get_node();
        construct(&p->data, x); //全局，构造/析构基本工具
        return p;
    }
    //销毁（析构并释放）一个节点
    void destory_node(link_type p) {
        destory(&p->data);
        put_node(p);
    }

list提供有许多constructors，其中一个是default constructor，允许我们不指定任何参数做出一个空的list出来：

public:
    list() { empty_initialize(); } //产生一个空链表
protected:
	void empty_initialize() {
        node = get_node(); //配置一个节点空间，令node指向它
        node->next = node; //令node头尾指向自己，不设元素值
        node->prev = node;
    }

尾插：当以push_back()将新元素插入于list尾端时，此函数内部调用insert()：

void push_back(const T& x) { insert(end(), x); }

insert()是一个重载函数，有多种形式，其中最简单的一种如下，符和以上所需。首先配置并构造一个节点，然后再尾端进行适当的指针操作，将新节点插入进去；插入完成后，新节点将位于哨兵迭代器（标示出插入点）所指之节点的前方。

//函数目的：在迭代器position所指位置插入一个节点，内容为x
iterator insert(iterator position, const T& x) {
    link_type tmp = create_node(x); //产生一个节点（设妥内容为x）
    //调整双向指针，使tmp插入进去
    tmp->next = position.node;
    tmp->prev = position.node->prev;
    (link_type(position.node->prev))->next = tmp;
    position.node->prev = tmp;
    return tmp;
}

6 list的元素操作

6.1 push_front()和push_back()

//插入一个节点，作为头节点
void push_front(const T& x) { insert(begin(), x); }
//插入一个节点，作为尾节点
void push_back(const T& x) { insert(end(), x); }

6.2 erase()

//移除迭代器 position 所指节点，返回 position 的下一个节点
iterator erase(iterator position) {
    link_type next_node = link_type(position.node->next);
    link_type prev_node = link_type(position.node->prev);
    prev_node->next = next_node;
    next_node->prev = prev_node;
    destory_node(position.node);
    return iterator(next_node);
}

6.3 pop_front()和pop_back()

//移除头节点
void pop_front() { erase(begin()); }
//移除尾节点
void pop_back() {
    iterator tmp = end();
    erase(--tmp);
}

6.4 clear()

//清除所有节点（整个链表）
template <class T, class Alloc>
void list<T, Alloc>::clear() {
    link_type cur = (link_type)node->next;
    while(cur != node) { //遍历每一个节点
        link_type tmp = cur;
        cur = (link_type)cur->next;
        destory_node(tmp);	//销毁（析构并释放）一个节点
    }
    //恢复node原始状态
    node->next = node;
    node->prev = node;
}

6.5 remove()

//将数值为value之所有元素移除
template <class T, class Alloc>
void list<T, Alloc>::remove(const T& value) {
    iterator first = begin();
    iterator last = end();
    while(first != last) { //遍历每个节点
        iterator next = first;
		++next;
        if(*first == value) erase(first);	//找到就移除
        first = next;
    }
}

6.6 unique()

//移除数值相同的连续元素。注意，只有“连续而相同的元素”，才会被移除剩一个
template <class T, class Alloc>
void list<T, Alloc>::unique() {
    iterator first = begin();
    iterator last = end();
    if(first == last) return;	//空链表，什么都不必做
    iterator next = first;
    while(++next != last) {		//遍历每一个节点
        if(*first == *next)		//如果在此区段中有相同的元素
        	erase(next)			//移除之
        else
            first = next;		//调整指针
        next = first;			//修正区段范围
    }
    
}

6.7 迁移操作transfer()

list内部提供一个所谓的迁移操作（transfer）：将某连续范围的元素迁移到某个特定位置之前。技术上很简单，节点间的指针移动而已。这个操作为其他的复杂操作如splice,sort,merge奠定了基础。

//将[first, last)内的所有元素移动到position之前
void transfer(iterator position, iterator first, iterator last) {
    if(position != last) {
        (*(link_type((*last.node).prev))).next = position.node;	//(1)
        (*(link_type((*first.node).prev))).next = last.node;	//(2)
        (*(link_type(*position.node).prev))).next = first.node;	//(3)
        link_type tmp = link_type((*position.node).prev);		//(4)
        (*position.node).prev = (*last.node).prev;				//(5)
        (*last.node).prev = (*first.node).prev;					//(6)
        (*first.node).prev = tmp;								//(7)
    }
}

6.8 接合操作splice()

上述transfer并非公开接口，list公开提供的是所谓的接合操作（splice）：将某连续范围的元素从一个list移动到另一个（或同一个）list的某个定点。

//将x接合于position所指位置之前。x必须不同于*this
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);
}

6.9 合并merge()

//merge()将x合并到*this身上，两个lists的内容都必须先经过递增排序
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();
    
    //注意：前提是两个list都已经过递增排序
    while(first1 != last1 && first2 != last2) {
        if(*first2 < *first1) {
            iterator next = first2;
            transfer(first1, first2, ++next);
            first2 = next;
        }
        else
            ++first1;
    }
    if(first2 != last2) transfer(last1, first2, last2);
}

6.10 逆向重置链表reverse()

template<class T, class Alloc>
void list<T, Alloc>::reverse() {
    //如果是空链表或仅有一个元素，则不进行任何操作
    //使用size() == 0 || size() == 1来判断也可，但较慢
    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);
    }
}

6.11 排序sort()

list不能使用STL算法sort()，必须使用自己的sort() member function。因为STL算法sort()只接受RandomAccessIterator。

1. template<class T, class Alloc>
   void list<T, Alloc>::sort() {
       //如果是空链表或仅有一个元素，则不进行任何操作
       //使用size() == 0 || size() == 1来判断也可，但较慢
       if(node->next == node || (link_type)(node->next)->next == node) return;
   	
       //一些新的lists，作为中介数据存放区
       list<T, Alloc> carry;
       list<T, Alloc> counter[64];
       int fill = 0;
       while(!empty()) {
           carry.splice(carry.begin(), *this, begin());
           int i = 0;
           while(i < fill && !counter[i].empty()) {
               counter[i].merge(carry);
               cary.swap(counter[i++]);
           }
           carry.swap(counter[i]);
           ig(i == fill) ++fill;
       }
       
       for(int i = 1; i < fill; ++i)
           counter[i].merge(counter[i - 1]);
       swap(counter[fill - 1]);
   }