带头尾节点的双向链表

#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;
}