双向链表

#include<iostream>
using namespace std;
#include <assert.h>


typedef int DataType;


class LinkNode
{
	friend class List;
public:
	LinkNode(const DataType& x)
		:_data(x)
		, _prev(NULL)
		, _next(NULL)
	{}
private:
	DataType _data;
	LinkNode* _prev;
	LinkNode* _next;
};


class List
{
public:
	List()
		: _head(NULL)
		, _tail(NULL)
	{}
public:
	void PushBack(const DataType& x)
	{
		//空
		//一个或一个以上节点
		if (_head == NULL)
		{
			_head = new LinkNode(x);
			_tail = _head;
		}
		else
		{
			LinkNode* end = new LinkNode(x);
			_tail->_next = end;
			end->_prev = _tail;
			_tail = end;
		}
	}


	void Print()
	{
		if (_head == NULL)
		{
			return;
		}
		else
		{
			LinkNode* begin = _head;
			while (begin)
			{
				cout << begin->_data << " ";
				begin = begin->_next;
			}
			cout << endl;
		}
	}


	void PopBack()
	{
		//空
		//一个
		//多个
		if (_head == NULL)
		{
			return;
		}
		else if (_head == _tail)
		{
			delete _head;
			_head = NULL;
			_tail = NULL;
		}
		else
		{
			LinkNode* del = _tail;
			_tail = _tail->_prev;
			delete del;
			_tail->_next = NULL;
		}
	}


	void PushFront(const DataType& x)
	{
		//空
		//一个或多个节点
		if (_head == NULL)
		{
			_head = new LinkNode(x);
			_tail = _head;
		}
		else
		{
			LinkNode* begin = new LinkNode(x);
			begin->_next = _head;
			_head->_prev = begin;
			_head = begin;
		}
	}


	void PopFront()
	{
		//空
		//一个
		//多个节点
		if (_head == NULL)
		{
			return;
		}
		else if (_head == _tail)
		{
			delete _head;
			_head = NULL;
			_tail = NULL;
		}
		else
		{
			LinkNode* del = _head;
			_head = _head->_next;
			delete del;
			_head->_prev = NULL;
		}
	}


	LinkNode* Find(const DataType& x)
	{
		LinkNode* begin = _head;
		while (begin)
		{
			if (begin->_data == x)
			{
				return begin;
			}
			begin = begin->_next;
		}
		return NULL;
	}


	void Insert(LinkNode* pos, const DataType &x)
	{
		assert(pos);
		if (pos == _tail)
		{
			PushBack(x);
		}
		else{
			LinkNode* tmp = new LinkNode(x);
			tmp->_next = pos->_next;
			pos->_next->_prev = tmp;
			pos->_next = tmp;
			tmp->_prev = pos;
		}


	}


	void Erase(LinkNode* del)
	{
		assert(del);
		if (del == _head)
		{
			_head = _head->_next;
			delete del;
			_head->_prev = NULL;
		}
		else if (del == _tail)
		{
			PopBack();
			//有问题
			//_tail = _tail->_prev;
			//delete del;
			//_tail->_next == NULL;
		}
		else
		{
			del->_prev->_next = del->_next;
			del->_next->_prev = del->_prev;
			delete del;
		}
	}


	void Reverse()
	{
		LinkNode* begin = _head;
		LinkNode* end = _tail;
		while (begin != end && begin->_prev != end)
		{
			swap(begin->_data, end->_data);
			begin = begin->_next;
			end = end->_prev;
		}
	}


private:
	LinkNode* _head;
	LinkNode* _tail;
};


void Test1()
{
	List l1;
	//l1.PushBack(5);
	//l1.PushBack(5);
	//l1.PushBack(5);
	//l1.PushBack(5);
	//l1.PushBack(5);
	l1.PushFront(2);
	l1.PushFront(3);
	l1.PushFront(7);
	l1.PushFront(5);
	l1.PushBack(8);
	l1.Print();
	l1.Reverse();
	//LinkNode* ret = l1.Find(2);
	//l1.Erase(ret);
	//l1.Insert(ret, 11);
	//l1.PopFront();
	//l1.PopFront();
	//l1.PopFront();


	//l1.PopFront();
	l1.Print();
	//l1.PopBack();
	//l1.PopBack();
	//l1.PopBack();
	//l1.Print();
}


int main()
{
	Test1();
	system("pause");
	return 0;
}