STL List 的实现

list 数据结构的实现

1.双链表，始终存在着一个空节点。
2.迭代器的实现，内嵌型别为 bidirectional_iterator
3.节点的结构体
4.list 结构的实现
5.使用配置器 alloctor 配置 构造分离 析构 释放分离

#include <iostream>
#include <memory>
#include <cstddef>
using namespace std;

//#define __USE_MALLOC
//typedef typename  malloc_alloc alloc;

template<class T>
struct _list_node
{
    _list_node<T> * prev;
    _list_node<T> * next;
    T data;
};

template<class T, class Ref ,class Pr>
struct _list_iterator
{
    typedef _list_iterator<T,T*,T&> iterator;
    typedef _list_iterator<T,Ref,Pr> self;

    typedef bidirectional_iterator_tag iterator_category;
    typedef T   value_type;  
    typedef Pr  pointer;
    typedef Ref reference;
    typedef _list_node<T>* link_type;
    //typedef size_t size_type;
    typedef ptrdiff_t difference_type;

    link_type node;
    //construct function
    _list_iterator(link_type x):node(x){}
    _list_iterator();
    _list_iterator(const iterator&x):node(x){}

    //member function
    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 ;}

    self& operator++() 
    {
        node = (link_type)((*node).next);
        return *this;
    }
    self operator++(int)
    {
        self tmp = *this;
        ++(*this);
        return tmp;
    }
    self& operator--()
    {
        node = (link_type)((*node).prev);
        return node;
    }
    self operator--(int)
    {
        self tmp =*this;
        --(*this);
        return tmp;
    }
};

template<class T >
class List
{
    typedef _list_node<T> list_node;
    typedef _list_iterator<T,T&,T*> iterator;
    typedef T   value_type;
    typedef T*  pointer;
    typedef T& reference;

private:
    std::allocator<list_node> alloc_; //内存分配器

public:
    typedef list_node* link_type;

protected:
    link_type node;

    //typedef simple_alloc<list_node> list_node_allocate;

//constructor
protected:
    // 配置 释放 构造 销毁 四个函数
    link_type get_node()
    {

        return alloc_.allocate( sizeof (list_node));
    }
    void put_node(link_type p)
    {
        return alloc_.deallocate(p, sizeof (list_node));
    }
    link_type creat_node(const T&x)
    {
        link_type p=get_node();
        alloc_.construct( &(p->data),x);
        return p;
    }
    void destory_node(link_type p)
    {
        alloc_.destroy(&(p->data));
        put_node(p);
    }
    void empty_initialize()
    {
        node = get_node();
        node->next = node;
        node->prev = node;
    }
public:
    List(){empty_initialize();}
public:
    iterator begin() {return (link_type) (*node).next;}
    iterator end()   {return (link_type) node;}
    bool     empty(){return node==(node->next);}
public:
    iterator insert(iterator position ,const T& x)
    {
        link_type tmp = creat_node(x);
        tmp->next = position.node;
        tmp->prev  = position.node->prev;
        (link_type(position.node->prev)->next) = tmp;
        position.node->prev = tmp;
        return tmp;
    }

    void push_back(const T& x)
    {
        insert(end(),x);
    }
    void push_front(const T& x)
    {
        insert(begin(),x);
    }
    iterator erase(iterator position)
    {
        link_type next_node = link_type(position.node->next);
        link_type prev_node = link_type(position.node->prev);

        next_node->prev = prev_node;
        prev_node->next = next_node;

        destory_node(position.node);
        return iterator(next_node);
    }
    void pop_front() {erase(begin() );} //移除头结点
    void pop_back()
    {
        iterator tmp = end();
        erase(--tmp);
    }
    //清除整个链表
    void clear()
    {
        link_type cur =(link_type)node ->next;
        while(cur != node )
        {
            link_type tmp = cur;
            cur = tmp->next;
            destory_node(tmp);
        }
        node->next =node;
        node->prev =node;
    }
    void remove(const T& x)  //移除数值为 x 的元素
    {
        iterator first = begin();
        iterator last  =end();
        while(first!=last)
        {
            iterator next = first;
            ++next;
            if(*first ==x) erase(first);
            first = next;
        }
    }
    void 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;
        }
    }
    void swap(List<T> &x)
    {
        // transfer(begin(),x.begin(),x.end());
        ::swap(x.node,node);
    }

    void transfer(iterator position, iterator first, iterator last);

    void splice(iterator position ,List<T>& x,iterator i);

    void merge(List<T> &x);

    void reverse();

    void sort();


};

template<class T>
void List<T > :: transfer(iterator position, iterator first, iterator last)
{
    if(position!= last && position != first)
    {
        link_type position_node_prev = (position.node->prev);
        link_type last_node_prev     = (last.node->prev);
        link_type first_node_prev    = (first.node->prev);
        position_node_prev->next = first.node;
        first.node->prev          = position_node_prev;
        first_node_prev->next    = last.node;
        last.node->prev          = first_node_prev;
        last_node_prev->next     = position.node;
        position.node->prev       = last_node_prev;
    }
}

template<class T>
void List<T>:: splice(iterator position ,List<T>& x, iterator i)
{
    iterator j=i;
    ++j;
    if(position ==i||position ==j) return ;
    transfer(position,i,j);
}

template<class T>
void List<T> :: merge(List<T> &x)
{
    iterator first1= begin();
    iterator last1 = end();
    iterator first2= x.begin();
    iterator last2 = x.end();
    while(first1!=last1 && first2!=last2)
    {
        if(*first1>*first2)
        {
            iterator next =first2;
            transfer(first1,first2,++next);
            first2 = next;
        }
        else
            ++first1;
    }
    if(first2 != last2 ) transfer(last1,first2,last2);
}
template<class T>
void List<T>:: reverse()
{
    if(node->next == node || (node->next->next) == node )
        return ;
    iterator first = begin();
    ++first;
    while(first != end())
    {
        iterator old = first;
        ++old;
        transfer(begin(),first,old);
        first=old;
    }
}   

template<class T>
void List<T> :: sort()
{
    if(node->next == node || (node->next->next) == node )
        return;
    List<T > carry;
    List<T > 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=0;i<fill;++i)
    {
        counter[i].merge(counter[i-1]);
    }
    swap(counter[fill-1]);


}
int main()
{
    List<int> a;
    a.push_back(3);
    a.push_back(4);
    a.push_back(5);
    a.push_back(6);
    //cout<<*(a.begin())<<endl;

    List<int >b;
    b.push_back(1);
    b.push_back(14);
    b.push_back(3);
    b.push_back(19);

    b.sort();

    a.merge(b); 

    a.unique();

    a.remove(3);

    a.reverse();

    a.push_front(67);
    for(auto iter= a.begin();iter!=a.end();++iter)
        cout<<*iter<<endl;
}