数据结构--链表（C++）

一、ListNode模板类

typedef int Rank
#define ListNodePosi(T) ListNode<T>*

template<typename T> class ListNode {
public:
    T data; ListNodePosi(T) PreNode; ListNodePosi(T) BackNode;  //数据，前驱，后继
    ListNode(){}
    ListNode(T e,ListNodePosi(T) p=NULL,ListNodePosi(T) s=NULL)
        :data(e),PreNode(p),BackNode(s){}
    ~ListNode(){}
    ListNodePosi(T) insertAsPred(T const & e);  //在当前节点之前插入新的节点
    ListNodePosi(T) insertAsBack(T const & e);  //在当前结点之后插入新的结点
};

template<typename T>
ListNode<T>::insertAsPred(T const & e) {
    ListNodePosi(T) x=new ListNode(e,PreNode,this);
    PreNode->BackNode=x;
    PreNode=x;     //更新前驱结点
    return x;
}

template<typename T>
ListNode<T>::insertAsBack(T const & e) {
    ListNodePosi(T) x=new ListNode(e,this,BackNode);
    BackNode->PreNode=x;
    BackNode=x;   //更新后继结点
    return x;
}

二、List模板类

template<typename T> class List : public ListNode<T> {
private:
    int _size; ListNodePosi(T) header;ListNodePosi(T) trailer;  //规模，头指针，尾指针
public:
    List();
    ~List();
public:
    int size(){return _size;}     //返回规模大小
    ListNodePosi(T) first() { return this->header; }  //返回头结点
    ListNodePosi(T) last() { return this->trailer; }  //返回尾结点
    bool empty(){ return _size<=0; }     //判断是否为空

    ListNodePosi(T) insertAsFirst(T const & e); //在首元结点前插入新结点
    ListNodePosi(T) insertAsLast(T const & e); //在尾指针前插入新结点
    ListNodePosi(T) insertAsBefore(ListNodePosi(T) p,T const & e);
    ListNodePosi(T) insertAsAfter(ListNodePosi(T) p,T const & e);
    T remove(ListNodePosi(T) p);  //删除p结点
    void clear();   //清除链表所有结点

    void sort(ListNodePosi(T) p,int n);  //归并排序
    void merge(ListNodePosi(T) p,int n,List<T>& L,ListNodePosi(T) q,int m); //归并操作
    ListNodePosi(T) search(T const & e) const; //查找
};

//构造函数，对成员变量的初始化
template<typename T>
List<T>::List(){
    header=new ListNode<T>;
    trailer=new ListNode<T>;
    header->BackNode=trailer;header->PreNode=NULL;
    trailer->PreNode=header;trailer->BackNode=NULL;
    _size=0;
}

//析构函数，将成员变量的内存释放
template<typename T>
List<T>::~List(){
    delete header,trailer;
}

//在首元结点之前插入新结点
template<typename T>
ListNodePosi(T) List<T>::insertAsFirst(T const & e) {
    _size++; //规模增加
    return header->insertAsBack(e);
} 

//在尾指针之前插入结点
template<typename T>
ListNodePosi(T) List<T>::insertAsLast(T const & e) {
    _size++;
    return trailer->insertAsPred(e);
}

//在p结点之前插入新结点
template<typename T>
ListNodePosi(T) List<T>::insertAsBefore(ListNodePosi(T) p,T const & e) {
    _size++;
    return p->insertAsPred(e);
}

//在p点之后插入新结点
template<typename T>
ListNodePosi(T) List<T>::insertAsAfter(ListNodePosi(T) p,T const & e) {
    _size++;
    return p->insertAsBack(e);
}

//删除节点
template<typename T>
T List<T>:: remove(ListNodePosi(T) p) {
    _size--;T e=p->data;
    p->PreNode->BackNode=p->BackNode;
    p->BackNode->PreNode=p->PreNode;
    delete p;
    reutrn e;
}

//清除所有结点
template<typename T> 
void List<T>::clear() {
    while( _size>0 ) {
        remove(header->BackNode);
    }
}

//归并排序
template<typename T>
void List<T>::merge(ListNodPosi(T) p,int n,List<T> L,ListNodePosi(T) q,int m) {
    ListNodePosi(T) pp=p->PreNode;
    while(0<m) {
        if(0<n && (p->data <= q->data)) {
            if(q==(p=p->BackNode)) break;
            n--;
        } else {
            //insertAsBefore(p,q->data);
            //q=q->BackNode;
            //remove(q->PreNode);
            insertAsBefore(p,L->remove((q=q->BackNode)->PreNode));
            m--;
        }
    p=pp->BackNode;
}

//归并排序
template<typename T>
void List<T>::sort(ListNodePosi(T) p,int n) {
    if(n<2) return;
    int m=n>>1;
    ListNodePosi(T) q=p;
    for(int i=0;i<m;i++)q=q->BackNode();
    sort(p,m);sort(q,n-m);    //以递归方式进行排序
    merge(p,m,*this,q,n-m);   //归并      
}

//查找
template<typename T>
ListNodePosi(T) List<T>::search(T const & e) {  //从后向前遍历，返回靠后的匹配项
    int n=_size; ListNodePosi(T) p=trailer;
    while(0 < n--) {
        if(((p=p->PreNode)->data)==e)break;
    }
    return p;
}

以上代码实现的是双向链表，基本实现了链表的基本增、删、查、改的功能，在此基础上，还实现了链表的归并操作，和归并排序算法。