从零开始写STL-容器-list

从零开始写STL-容器-list

• List 是STL 中的链表容器，今天我们将通过阅读和实现list源码来解决一下问题：
• List内部的内存结构是如何实现的？
• 为什么List的插入复杂度为O(1)？
• 为什么List的size()函数复杂度为O(n)?

list 容器的幕后英雄 - list 结点

作为一个链表首先要维护数据（模板元素的实例内容），指向前一个节点的指针 和 指向后一个节点的指针。List 的 结点作为list 容器中 元素内容 和 容器组织逻辑的一个中间层。

• 为什么不能搞成单向链表？
  如果单向链表的话，请您试想一下要删除迭代器pos指向的元素应该怎么操作？我们必须知道前驱后继才能正确进行删除

for(auto it = begin(); it != end(); it++)
{
    if(it->next == pos)
    {
        //...逻辑代码
    }
}

这样的单向链表每次寻找一个节点的前驱 后继 都要经过最坏复杂度为O(n)的查询，所有应该实现为双向链表。

list 容器的 迭代器

• 维护一个指向list_node 的指针

    template<class T>
    struct list_iterator : public bidirectional_iterator<T>
    {}//继承bidirectional_iterator类 便于类型萃取 和 特定算法应用

list 容器的 逻辑结构

• 环状链表

  node 表示尾部的一个空白结点，其next 指向list的头节点, pre指向list的尾节点

为什么这样设计？
首先list作为双向链表需要提供向前和向后的迭代能力，这样设计可以在O1的时间获得首尾元素，而且可以避免链表为空时的边界检查（只需要看一下node->pre == node，则为空）

        node_ptr get_node()
        {
            return data_allocator.allocate(1);
        }
        node_ptr new_node(const T& x)
        {
            node_ptr p = get_node();
            construct(&p->data, x);
            p->next = p->pre = nullptr;
            return p;
        }

构造函数

        list()
        {
            //注意 typedef  std::allocator<list_node<T>> Data_allocator;
            node.ptr = data_allocator.allocate(1);
            node.ptr->next = node.ptr->pre = node.ptr;
        }
        list(const self& rhs) :list(rhs.begin(), rhs.end())
        {
    
        }
        list(std::initializer_list<T> li):list(li.begin(),li.end())
        {

        }
        template<class c>
        list(const c l,const c r)
        {
            node.ptr = data_allocator.allocate(1);
            node.ptr->next = node.ptr->pre = node.ptr;
            for (auto it = l; it != r; it++)
            {
                push_back((*it));//逐个插入到list的末端
            }
        }
        list(size_type n, const T& val)
        {
            node.ptr = data_allocator.allocate(1);//初始化node
            node.ptr->next = node.ptr->pre = node.ptr;
            while (n--)
                push_back(val);
        }

析构函数

遍历列表 销毁数据实例

        ~list()
        {
            if (!empty())
            {
                for (iterator it = begin(); it != end(); )
                {
                    data_allocator.destroy(&it.ptr->data);
                    it++;
                }
            }
        }

Modify

• 注意指针操作的先后顺序

        void push_front(const T& x)
        {
            node_ptr p = new_node(x);
            node.ptr->next->pre = p;
            p->next = node.ptr->next;
            node.ptr->next = p;
            p->pre = node.ptr;
        }
        void push_back(const T& x)
        {
            node_ptr p = new_node(x);
            node.ptr->pre->next = p;
            p->pre = node.ptr->pre;
            p->next = node.ptr;
            node.ptr->pre = p;
        }
        void pop_front()
        {
            node_ptr tmp = node.ptr->next;
            node.ptr->next = node.ptr->next->next;
            node.ptr->next->pre = node.ptr;
            data_allocator.deallocate(tmp,sizeof(list_node));
        }
        void pop_back()
        {
            node_ptr tmp = node.ptr->pre;
            node.ptr->pre = tmp->pre;
            tmp->pre->next = node.ptr;
            data_allocator.deallocate(tmp, sizeof(list_node));
        }
        iterator erase(iterator pos)
        {
            pos.ptr->pre->next = pos.ptr->next;
            pos.ptr->next->pre = pos.ptr->pre;// 前驱 后继 结点的指针操作
            node_ptr tmp = pos.ptr->next;
            destroy(&pos.ptr->data);//销毁
            data_allocator.deallocate(pos.ptr,sizeof(list_node));// 回收内存
            return iterator(tmp);
        }
        iterator erase(iterator first, iterator last)
        {
            first.ptr->pre->next = last.ptr;
            last.ptr->pre = first.ptr->pre;
            for (auto it = first; it != last; it++)
                destroy(&it.ptr->data);
            return first;
        }
        //The list container is extended by inserting new elements before the element at position.
        iterator insert(iterator pos, const T& x)
        {
            node_ptr p = new_node(x);
            pos.ptr->pre->next = p;
            p->pre = pos.ptr->pre;
            p->next = pos.ptr;
            pos.ptr->pre = p;
            return pos;
        }

        void insert(iterator pos, size_type sz, const T& x)
        {
            while (sz--)
                insert(pos, x);
        }

Splice 函数

        /* 将 first到last的元素移动到 pos 之前 */
        void transfer(iterator pos, iterator first, iterator last)
        {
            if (pos != last)
            {
                last.ptr->pre->next = pos.ptr;
                first.ptr->pre->next = last.ptr;
                pos.ptr->pre->next = first.ptr;
                auto tmp = pos.ptr->pre;
                pos.ptr->pre = last.ptr->pre;
                last.ptr->pre = first.ptr->pre;
                first.ptr->pre = tmp;
            }
        }
        void splice(iterator pos, list<T>& rhs)
        {
            if (*this != rhs)
                transfer(pos, rhs.begin(), rhs.end());
        }
        void splice(iterator pos, list<T>& rhs, iterator first, iterator last)
        {
            if (*this != rhs)
            {
                transfer(pos, first, last);
            }
        }
        void splice(iterator pos, list<T>& rhs, iterator it)
        {
            it.ptr->pre->next = it.ptr->next;
            it.ptr->next->pre = it.ptr->pre;
            pos.ptr->pre->next = it.ptr;
            it.ptr->pre = pos.ptr->pre;
            pos.ptr->pre = it.ptr;
            it.ptr->next = pos.ptr;
        }

merge 函数

注意链表的merge函数 和算法库中含义有所不同，在这里会将参数链表全部合并进来（也就是说在调用完这个函数之后，other 参数应该是空）

        void merge(list<T> &other)
        {
            auto p1 = begin(), p2 = other.begin();
            while (p1 != end() && p2 != other.end())
            {
                if (*p1 < *p2)
                    p1++;
                else if (*p1 >= *p2)
                {
                    auto tmp = p2;// 注意保存迭代器下一个位置，如果不保存，直接再调用splice之后p2++会怎样？首先p2!=other.end()这个条件永远不会触发，因为p2已经到了this的链表中
                    tmp++;
                    splice(p1, other, p2);
                    p2 = tmp;
                }
            }
            if (!other.empty()) {
                splice(end(), other);
            }
        }
        

list 归并排序的非递归形式(难点)

非递归形式的 归并排序，因为List并不支持随机存取迭代器，sort不能用于排序list。
归并的思路如下：先建立64个桶，然后从前向后遍历，每次从要排序的list头取出一个元素插入桶中，第一个桶要存的元素最多为1个，第二个桶要存的最多为2个，第K个桶最多为2^K个元素。在插入元素的时候从前向后插入，如果到达当前桶的上限就向后归并。
具体的算法实现极为巧妙！
个人感觉参考了位运算的进位性质

        void sort()
        {
            if (size() <= 1)
            {
                return;
            }
            self carry;
            self 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);
                    carry.swap(counter[i++]);
                }
                carry.swap(counter[i]);
                if (i == fill)
                {
                    ++fill;
                }
            }
            for (int i = 1; i < fill; i++)
            {
                counter[i].merge(counter[i - 1]);
            }
            swap(counter[fill - 1]);
        }