c++实现链式表的类模板

在写链表反转的时候很苦恼，感谢这位博主的图http://blog.csdn.net/u013271921/article/details/46382345

然后自己画了几遍，终于是理解了

/*
类模板双向链表，通过一个节点类node和一个链表类chlist来实现，node中包含前驱指针pr,后继指针nx，和数据域data，并且data可接受任意类型的数据
链表类chlist包含逆序创建链表操作，指定位置插入操作，指定位置删除操作，寻找指定位置元素操作和翻转链表等操作，并且包含指向链表的头指针、尾指针和表长
chlist中的成员函数：
														1.Createlist逆序创建链表
														2.insertz指定位置插入
														3.erasez指定位置删除
														4.findz输出并返回指定位置的元素
														5.reversal反转链表
														6.chlist创建空链表
														7.~chlist析构函数
														8.push_front头插
														9.push_back尾插
														10.pop_front头删
														11.pop_back尾删
														12.length输出并返回表长
														13.clear清空链表
在下面的代码中
														1.e代表T类型的元素
														2.i代表位置
作者:chczy
2017/10/16	星期一	下午9：08
*/
#include<iostream>
#include<algorithm>
#include<new>
using namespace std;
template<class T>
struct node {
	node *pr;//前驱指针
	node *nx;//后继指针
	T data;//数据

};//节点类
//双向链表类
template<class T>
class chlist {
public:
	chlist();
	~chlist() { cout <<"destroy chlist. "<< endl; };
	chlist& operator=(const chlist&);
	bool Createlist(int n);//创建空链表
	node<T>* insertz(int i, T e);//在i位置插入元素d
	node<T>* erasez(int i);//删除i位置的元素
	node<T>* findz(int i);//寻找i位置的元素
	node<T>* reversal();//反转链表
	node<T>* push_front(T e);//头插
	node<T>* push_back(T e);//尾插
	node<T>* pop_front();//头删
	node<T>* pop_back();//尾删
	bool empty();//检查链表是否为空
	void clear();//将链表置空
	void display();//输出链表的所有元素
	int length();
private:
	node<T> *head;//头指针
	node<T> *tail;//尾指针
	int len;//表长
};
template<class T>
chlist<T>::chlist()//creat a null list
{
	head = NULL;
	tail = NULL;
	len = 0;
}

template<class T>
bool chlist<T>::Createlist(int n)//不断在表头添加元素，逆序建立链表
{
	if (empty())
	{
		node<T> *L = new node<T>;
		L->pr = NULL;
		L->nx = NULL;
		int i = n;
		while (n--)
		{
			node<T> *p = new node<T>;
			cin >> p->data;
			p->nx = L->nx;//接到后一个节点
			p->pr = L;	  //反连接到头结点L
			L->nx = p;	  //L链接到新节点
			if (i > n + 1)//当连接了2个节点以上时
				p->nx->pr = p;//旧节点反链接到新节点
			if (i == n + 1)//将第一个接入的节点设置为尾节点
				tail = p;
		}
		head = L;//head指向头结点(第一个节点之前的节点)
		len = i;//存表长
		return 1;//创建成功返回1
	}
	else
		return 0;//否则返回0
}

template<class T>
node<T>* chlist<T>::insertz(int i, T e)
{
	if (i > len+1)
	{
		throw"out of range!\n";
	}
	if (i == 1&&len!=0)//如果要插入第一个位置
	{
		node<T>* s=push_front(e);//则执行头插
		return s;
	}
	else if (i == len+1&&len!=0)//如果要插入最后一个位置
	{
		node<T>* s = push_back(e);//则执行尾插
		return s;
	}
	else if (len == 0)
	{
		node<T> *s = new node<T>;
		s->data = e;
		head->nx = s;
		s->pr = head;
		s->nx = NULL;
		tail = s;
		++len;
	}
	else
	{
		node<T>* p = head;
		int j = 0;  
		while (p&&j <= i - 1)
		{
			p = p->nx;
			++j;
		}
		node<T> *s = new node<T>;
		s->data = e;
		(p->pr)->nx = s;
		s->nx = p;
		s->pr = p->pr;
		p->pr = s;
		++len;
		return s;
	}
}

template<class T>
node<T>* chlist<T>::erasez(int i)
{
	if (i > len&&i < 0)
	{
		throw"out of range!\n";
	}
	if (i == 1&&len!=1)
	{
		node<T>* s = pop_front();
		return s;
	}
	else if (i == len&&len != 1)
	{
		node<T>* s = pop_back();
		return s;
	}
	if (len == 1)
	{
		node<T>* s = head->nx;
		head->nx = NULL;
		tail = NULL;
		delete s;
		--len;
		return head;
	}
	else//长度不为1，且删除位置不为头尾，即一般情况
	{
		int j = 0;
		node<T> *p = head;
		while (p&&j <= i - 1)//寻找待删除节点
		{
			p = p->nx;
			++j;
		}
		node<T>* s = p->nx;//s为删除节点的后一节点
		(p->pr)->nx = s;//删除节点的前一节点的后继更新为s
		s->pr = p->pr;//s的前驱更新为删除节点的前一节点
		delete p;//删除p
		--len;//更新长度
		return s;//返回删除节点的后一节点
	}
}

template<class T>
node<T>* chlist<T>::findz(int i)
{
	if (i > len)
	{
		throw"out of range!\n";
	}
	node<T> *p=head;
	int j = 0;
	while (p&&j <= i - 1)
	{
		p = p->nx;
		++j;
	}
	cout <<i<< "位置的元素为:" << endl;
	cout << p->data << endl;
	return p; 
}

template<class T>
chlist<T>& chlist<T>::operator=(const chlist<T>& rhs)
{
	head = rhs.head;
	tail = rhs.tail;
	len = rhs.len;
	return *this;
}

template<class T>
node<T>* chlist<T>::reversal()//有问题
{
	node<T> *NH = NULL;//新头节点指针
	node<T> *Prev = NULL;//前一个指针
	node<T> *Node = head->nx;//节点指针
	tail = head->nx;//原来的头指针变为尾指针
	while (Node != NULL)//不遍历到最后一个(尾空)
	{
		node<T> *Next = Node->nx;
		if (Next == NULL)//Next指向了尾后
		{
			node<T> *p = new node<T>;
			p->pr = NULL;
			p->nx = Node;
			NH = p;
			head = p;//更新头指针,为新的第一节点之前的指针
		}
		Node->nx = Prev;//把Node的后继指针指向Node的元前一位元素
		Node->pr = Next;//把Node的前驱指向Node的元后一位元素
		Prev = Node;//更新Prev
		Node = Next;//更新Next
	}
	return NH;//返回头结点
}

template<class T>
bool chlist<T>::empty()
{
	if (len == 0)
		return 1;
	else
		return 0;
}

template<class T>
void chlist<T>::display()
{
	if (len == 0)
	{
		cout << "null list!" << endl;
		return;
	}
	node<T> *p = head->nx;
	cout << "表中元素为：" << endl;
	while (p != tail)
	{
		cout << p->data << endl;
		p = p->nx;
	}
	cout << p->data << endl;
	cout << "表长为" << len << endl;
}

template<class T>
void chlist<T>::clear()
{
	while (!empty()) { erasez(1);}
}

template<class T>
node<T>* chlist<T>::push_front(T e)//头插
{
	node<T>* s = new node<T>;
	s->data = e;
	s->nx = head->nx;
	head->nx = s;
	s->pr = head;
	(s->nx)->pr = s;
	++len;
	return s;
}
	
template<class T>
node<T>* chlist<T>::push_back(T e)//尾插
{
	node<T>* s = new node<T>;
	s->data = e;
	tail->nx = s;
	s->pr = tail;
	s->nx = NULL;
	tail = s;
	++len;
	return s;
}

template<class T>
node<T>* chlist<T>::pop_front()//头删
{
	node<T>* p = head->nx;//p指向第一个节点
	node<T>* s = p->nx;//s指向第二个节点
	head->nx = p->nx;//头结点的后继更新为第二个节点
	(p->nx)->pr = head;//第二个节点的前驱更新为头结点
	delete p;//删除第一个节点
	--len;//更新长度
	return s;//返回删除后的第一个节点的指针
}

template<class T>
node<T>* chlist<T>::pop_back()//尾删
{
	node<T> *p = tail;//p为最后一个节点
	node<T> *s = tail->pr;//s为倒数第二个节点
	s->nx = NULL;//s节点指向空，变为最后一个节点
	tail = s;//尾节点更新为s
	delete p;//删除p
	--len;//更新长度
	return s;//返回删除后的尾节点的指针s，此时s==tail
}

template<class T>
int chlist<T>::length()
{
	cout << "表长为:" << endl;
	cout << len << endl;
	return len;
}
//by chczy