C++实现简单的双向链表

vs2013下编译运行，实现了双向链表类List 的 构造函数，拷贝构造、析构函数、赋值运算符重载、清空、头插、头删、尾插、尾删、插入、删除、逆序和删除链表中重复的数据值函数等。

直接贴代码：

DuList.h 类声明、定义、成员函数定义。

#pragma once
//双向链表
#include<assert.h>
#include<iostream>
using namespace  std;

typedef int DataType;

struct ListNode
{
ListNode(DataType& x)
:_data(x)
,_prev(NULL)
, _next(NULL)
{}
DataType _data;
ListNode * _prev;
ListNode * _next;
};

class List
{
public:
List()
:_head(NULL)
, _tail(NULL)
{}
List(const List & l)
{
ListNode * end = l._tail;
while (end)
{
PushFront(end->_data);
end = end->_prev;
}
}
~List()
{
ListNode * begin = _head;
while (begin)
{
ListNode * tmp = begin;
begin = begin->_next;
delete tmp;
}
}
void Clear()  //清空链表
{
ListNode * begin = _head;
while (begin)
{
ListNode * tmp = begin;
begin = begin->_next;
delete tmp;
}
_head=_tail = NULL;  //最终结果
}
List& operator=(List &l)
{
List tmp(l);
swap(_head, l._head);
swap(_tail, l._tail);
return *this;
//tmp被析构
}
void PushBack(DataType &x)
{
ListNode * tmp = new ListNode(x);
if (_tail == NULL)
{
tmp->_next = _tail;
_head =_tail= tmp;
}
else
{
_tail->_next = tmp;
tmp->_prev = _tail;
_tail = tmp;
}
}
void PopBack()
{
if (_head == _tail)
{
delete _head;   //NULL也可以
_head = _tail = NULL;
}
else
{
ListNode * prev = _tail->_prev;
delete(_tail);
_tail = prev;

}
}
void PushFront(DataType & x)
{
ListNode * tmp = new ListNode(x);
if (_head == NULL)
{
_head = tmp;
_tail = tmp;
}
else
{
tmp->_next = _head;
tmp->_prev = NULL;
_head->_prev = tmp;
_head = tmp;
}  //可能没完
}

void Reverse()
{
assert(_head&&_tail);   //逻辑短路
ListNode * left = _head;
ListNode * right = _tail;
while (left!=right && left->_prev!=right)   //限定条件很重要
{
swap(left->_data, right->_data);
left = left->_next;
right = right->_prev;
}
}

void PopFront()
{
assert(_head);
if (_head == _tail)
{
delete _head;
_head = _tail = NULL;   //防止野指针
}
else
{
ListNode *tmp = _head;
_head = _head->_next;
delete tmp;
}
}
ListNode * Find(DataType & x)
{
ListNode * begin = _head;
while (begin)
{
if (begin->_data == x)  //x的类型必须重载了== 运算符
{
return begin;
}
begin = begin->_next;
}
return NULL;   //调用者需要检查结果是否合法
}
void Insert(ListNode * pos, DataType x)
{
//在结点之后插入
assert(pos);
ListNode * tmp = new ListNode(x);
if (_tail == pos)
{   //需要考虑_tail
_tail->_next = tmp;
tmp->_prev = _tail;
_tail = tmp;
}
else
{
tmp->_next = pos->_next;
tmp->_prev = pos;
tmp->_next->_prev = tmp;
pos->_next = tmp;
}
}
void Erase(ListNode* pos)
{
if (_head == _tail)
{
assert(_head == pos);
delete _head;
_head = _tail = NULL;
return;
}
if (pos == _head)
{
_head = _head->_next;
_head->_prev = NULL;   //防止野指针
}
else if (pos == _tail)
{
_tail = _tail->_prev;
_tail->_next = NULL;   //防止野指针
}
else
{
ListNode * prev = pos->_prev;
ListNode * next = pos->_next;
prev->_next = next;
next->_prev = prev;
}
delete pos;
}
void Print()
{
ListNode * begin=_head;
while (begin)
{
cout << begin->_data<<"->";
begin = begin->_next;
}
cout << "NULL"<<endl;
}

void Unique()
{
size_t size = 0;
ListNode * begin = _head;
while (begin)
{
ListNode *it = _head->_next;
while (it!=begin&&it!=NULL)
{
if (begin->_data == it->_data)
{
Erase(it);  //删除it保证指针不失效
break;
}
it = it->_next;
}
begin = begin->_next;

}

}
private:
ListNode * _head;
ListNode * _tail;
};

Main.cpp 测试用例

#include"DuList.h"

void Test1()
{
List l;
int a = 1;
l.PushFront(a);
l.PushFront(++a);
l.PushFront(++a);
l.Print();

List l2(l);
l2.Print();
}

void Test2()
{
List L;
int a = 1;
int b = 3;
L.PushFront(a);
L.Insert(L.Find(a), (DataType)6);

L.Insert(L.Find(a), (DataType)5);
L.Insert(L.Find(a), (DataType)4);
L.Insert(L.Find(a), (DataType)3);
L.Insert(L.Find(a), (DataType)2);

L.Print();

L.Reverse();
L.Print();
DataType i = 16;
L.PushBack(i);
L.PushBack(i);
L.Print();
L.Unique();
L.Print();
//List l3;
//l3.PushBack(i);
//l3.Print();
//L = l3;
//L.Print();
//l3.Clear();
//l3.Print();
//L.Erase(L.Find(b));
//L.Erase(L.Find(a));
//int c = 5;
//L.Erase(L.Find(c));
//c = 2;
//L.Erase(L.Find(c));
//c = 4;
//L.Erase(L.Find(c));

//L.Print();

}

void Test3()   //Unique
{
//List L2;
//DataType a = 9;
//L2.PushBack(a);
//L2.PushBack(a);
//L2.PushBack(++a);
//L2.PushBack(++a);
//L2.PushBack(++a);
//L2.PushBack(a);
//L2.PushBack(a);
//L2.Print();
//L2.Unique();
//L2.Print();
List L3;
DataType b = 100;
L3.PushFront(b);
L3.Print();
L3.Unique();
L3.Print();

}

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