带头尾节点的双向链表

#include<iostream>
#include<assert.h>
using namespace std;
typedef int DataType;
//双向链表，无头节点
struct LinkNode
{
	//struct默认是公有访问限定符
public:
	LinkNode(const DataType& x)
		:_data(x)
		, _prev(NULL)
		, _next(NULL)
	{}
	~LinkNode()
	{

	}
public:
	DataType _data;
	LinkNode* _prev;
	LinkNode* _next;
};

class List
{
public:
	List()
		:_head(NULL)
		, _tail(NULL)
	{
	}
	~List()
	{

	}
	void PushBack(const DataType& x)
	{
		LinkNode* tmp = new LinkNode(x);

		if (NULL == _tail)
		{
			_head = _tail=tmp;
		}
		else
		{
			tmp->_prev = _tail;
			_tail->_next = tmp;
			_tail = _tail->_next;

		}
	}
	void  PopBack()
	{
		LinkNode* cur = _head;
		if (_tail == NULL)
		{
			return;
		}
		else	if (_head == _tail)
		{
			delete _head;
			_head = _tail = NULL;
		}
		else
		{
			LinkNode* del = _tail;
			_tail->_prev->_next = NULL;
			_tail = _tail->_prev;
			delete del;
		}
	}
	void PushFront(const DataType& x)
	{
		LinkNode* tmp = new LinkNode(x);
		//如果没有节点
		if (NULL== _tail)
		{
			_tail=_head = tmp;
		}
		else 
		{
			tmp->_next = _head;
			_head->_prev = tmp;

			_head = tmp;

		}

	}
	void PopFront()
	{
		if (_head == NULL)
			return;
		else if (_head==_tail)
		{
			free(_head);
			_head = _tail=NULL;
		}
		else
		{
			LinkNode* del = _head;
			_head = _head->_next;
			_head->_prev = NULL;

			delete del;
		}
	}
	LinkNode* Find(const DataType& x)
	{
		LinkNode* cur = _head;
		while (cur)
		{
			if (cur->_data == x)
				return cur;
			cur = cur->_next;
		}
		return NULL;
	}
	void Erase(LinkNode* pos)
	{
		assert(pos);
		//处理pos是头，尾或头和尾
		LinkNode* del = NULL;
		if (pos == _head)
		{
			del = pos;
			_head = _head->_next;
			_head->_prev = NULL;
		}
		if (pos==_tail)
		{
			del = pos;
			_tail = _tail->_prev;
			_tail->_next = NULL;
		}
		if (del == NULL)
		{
			LinkNode* prev = pos->_prev;
			LinkNode* next = pos->_next;
			prev->_next = next;
			next->_prev = prev;
		}
		delete del;
	}
	void Insert(LinkNode* pos, const DataType& x)
	{
		assert(pos);
		LinkNode* tmp = new LinkNode(x);
		if (pos == _tail)
		{
			_tail->_next = tmp;
			tmp->_prev = _tail;
			_tail = tmp;
		}
		else
		{
			LinkNode* next = pos->_next;
			tmp->_next = next;
			next->_prev = tmp;

			pos->_next = tmp;
			tmp->_prev = pos;
		}
	}
	void  DisPlay()
	{
		LinkNode* cur = _head;
		while (cur)
		{
			cout << (cur->_data) << "->";
			cur = cur->_next;
		}
		cout << "NULL" << endl;
	}
private:
	LinkNode* _head;
	LinkNode* _tail;
};
void Test1()
{
	List l1;
	l1.PushBack(1);
	l1.PushBack(2);
	l1.PushBack(3);
	l1.PushBack(4);
	l1.PushBack(5);
	l1.PushBack(6);
	l1.DisPlay();

	l1.PopBack();
	l1.DisPlay();

	l1.PopBack();
	l1.PopBack();
	l1.PopBack();
	l1.PopBack();
	l1.PopBack();
	l1.PopBack();
	l1.PopBack();
	l1.PopBack();
	l1.DisPlay();

}
void Test2()
{
	List l2;
	l2.PushFront(1);
	l2.PushFront(2);
	l2.PushFront(3);
	l2.PushFront(4);
	l2.PushFront(5);
	l2.PushFront(6);
	l2.DisPlay();

	l2.PopFront();
	l2.PopFront();
	l2.PopFront();
	l2.PopFront();
	l2.DisPlay();
	l2.PopFront();
	l2.PopFront();
	l2.PopFront();
	l2.PopFront();
	l2.DisPlay();
}
void Test3()
{
	List l2;
	l2.PushFront(1);
	l2.PushFront(2);
	l2.PushFront(3);
	l2.PushFront(4);
	l2.PushFront(5);
	l2.PushFront(6);
	l2.DisPlay();

	LinkNode* ret = l2.Find(6);
	//l2.Erase(ret);

	l2.Insert(ret, 7);
	l2.DisPlay();
}
int main()
{
	Test3();
	system("pause");
	return 0;
}