数据结构--链表（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;
}