双向链表

.h文件

#ifndef LINKLIST_H
#define LINKLIST_H

typedef struct Node
{
	Node(const int data_);
	int data;
	Node* next;
	Node* pre;
}Node;


class LinkList
{
public:
	LinkList();
	LinkList(const LinkList&s);
	~LinkList();

public:
	//反转链表
	void Reverse();

	//头插
	void PushFront(int data);
	
	//在尾部插入一个结点
	void PushBack(int data);

	//打印链表
	void PrintList();

	//链表置空
	void Clear();

	//删除首结点
	void PopFront();

	//删除尾结点
	void PopBack();

	//在固定位置插入一个结点
	void Insert(Node* pos, int data);

	//删除某一个结点
	void Erase(Node* pos);

	//查找结点并返回这个结点的地址
	Node* Find(int& data);

	//计算链表结点的数目
	int Amount();

	//查找某结点并删除
	void Remove(int data);

private:
	Node* _head; //指向头结点
	Node* _tail; //指向尾结点
};



#endif

.cpp文件

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

//结点构造函数
Node::Node(const int data_) :data(data_), next(NULL), pre(NULL) {}


//链表类
LinkList::LinkList() : _head(NULL), _tail(NULL) {}

LinkList::LinkList(const LinkList&s)
	: _head(NULL), _tail(NULL)
{
	if (s._head == NULL)
		return;
	Node* tmp = s._head;
	while (tmp)
	{
		PushBack(tmp->data);
		tmp = tmp->next;
	}
}

LinkList::~LinkList()
{
	Clear();
}

void LinkList::PushFront(int data)
{
	if (_head == NULL)
	{
		PushBack(data);
	}
	else
	{
		Node* tmp = _head;
		_head = new Node(data);
		_head->next = tmp;
		tmp->pre = _head;
	}
}


void LinkList::PrintList()
{
	//头结点为空时，无需打印链表
	if (_head == NULL)
		return;
	else
	{
		Node* tmp = _head;
		while (tmp)
		{
			cout << tmp->data << "-->";
			tmp = tmp->next;
		}
		cout << "NULL" << endl;
	}
}

void LinkList::PushBack(int data)
{
	//链表为空时，插入结点后只有一个结点，此时_head=_tail
	if (_head == NULL)
	{
		_head = new Node(data);
		_tail = _head;
	}
	else
	{
		_tail->next = new Node(data);
		_tail->next->pre = _tail;
		_tail = _tail->next;
	}
}

void LinkList::Reverse()
{
	//交换前驱和后继指针
	swap(_head, _tail);
	Node* cur = _head;
	while (cur)
	{
		swap(cur->pre, cur->next);
		cur = cur->next;
	}
}

void LinkList::Clear()
{
	Node* begin = _head;
	while (begin != _tail)
	{
		_head = _head->next;
		delete begin;
		begin = _head;
	}
	_head = NULL;
	_tail = NULL;
	begin = NULL;
}

void LinkList::PopBack()
{
	if (_head == NULL)
	{
		cout << "List is empty" << endl;
		return;
	}
	else if (_head == _tail)
	{
		delete _head;
		_head = _tail = NULL;
	}
	else
	{
		Node* cur = _head;
		while (cur->next != _tail)
		{
			cur = cur->next;
		}
		delete _tail;
		_tail = cur;
		_tail->pre = cur->pre;
		_tail->next = NULL;
	}
}


void LinkList::PopFront()
{
	if (_head == NULL)
	{
		cout << "List is empty" << endl;
		return;
	}
	Node* tmp = _head;
	_head = _head->next;
	_head->pre = NULL;
	delete tmp;
}


void LinkList::Erase(Node* pos)
{
	assert(pos);
	if (pos == _tail)
		PopBack();
	else if (pos == _head)
		PopFront();
	else
	{
		pos->pre->next = pos->next;
		pos->next->pre = pos->pre;
		delete pos;
	}
}

void LinkList::Insert(Node* pos, int data)
{
	assert(pos);
	if (pos == _tail)
		PushBack(data);
	else
	{
		Node* tmp = new Node(data);
		tmp->next = pos->next;
		pos->next = tmp;
		tmp->next->pre = tmp;
		tmp->pre = pos;
	}
}

Node* LinkList::Find(int& data_)
{
	if (_head == NULL)
	{
		cout << "List is empty" << endl;
		return NULL;
	}
	else
	{
		Node* tmp = _head;
		while (tmp != NULL)
		{
			if (tmp->data == data_)
				return tmp;
			tmp = tmp->next;
		}
		return NULL;
	}
}

int LinkList::Amount()
{
	if (_head == NULL)
		return 0;
	else
	{
		int count = 0;
		Node* cur = _head;
		while (cur != _tail)
		{
			count++;
			cur = cur->next;
		}
		return ++count;
	}
}

void LinkList::Remove(int data)
{
	if (_head == NULL)
	{
		cout << "List is empty" << endl;
		return;
	}
	else
	{
		Node* tmp = Find(data);
		if (tmp != NULL)
			Erase(tmp);
	}
}

测试文件：

#include "stdafx.h"
#include "LinkList.h"

void Test1()
{
	LinkList list1;
	list1.PushBack(1);
	list1.PushBack(2);
	list1.PushBack(3);
	list1.PushBack(4);
	list1.PushBack(5);
	list1.PushBack(6);
	list1.PrintList();

	LinkList list2 = list1;
	list2.PrintList();
	list2.Reverse();
	list2.PrintList();
}

int main()
{
	Test1();
    return 0;
}