c++实现双向链表的常用功能

//结构体的定义
struct Node
{
	Node(const DataType& d)
		:_next(NULL)
		,_prev(NULL)
		,_data(d)
	{}
public:
	DataType _data;
	Node* _prev;
	Node* _next;
};
//双向链表类的定义
class DouList
{
	friend ostream& operator<<(ostream& os, DouList& l);
public:
	DouList()//构造函数
		:_head(NULL)
		,_tail(NULL)
	{}

	DouList(const DouList& l)//拷贝构造
	{
		if (l._head == NULL)
		{
			return;
		}
		Node *cur = l._head;
		Node *newNode = new Node(cur->_data);
		_head = newNode;
		_tail = _head;
		cur = cur->_next;
		while (cur)
		{
			newNode = new Node(cur->_data);
			_tail->_next = newNode;
			newNode->_prev = _tail;
			_tail = newNode;
			cur = cur->_next;
		}
	}

	DouList& operator=(DouList l)//=运算符的重载
	{
		swap(_head,l._head);
		swap(_tail, l._tail);
		return *this;
	}

	~DouList()//析构函数
	{
		Node* cur = _head;
		while (cur)
		{
			Node* del = cur;
			cur = cur->_next;
			delete del;
		}
		_head = NULL;
		_tail = NULL;
	}

public:
	void PushBack(const DataType& d);//后插
	void PopBack();//后出
	void PushFront(const DataType& d);//前插
	void PopFront();//前出
	Node* Find(const DataType& d);//查找
	void Insert(Node* pos, const DataType& d);//在指定位置插入
	void BubbSort();//冒泡排序
	void Reverse();//逆序
	void Remove(const DataType& d);//删除指定的元素
	void RemoveAll(const DataType& d);//删除所有指定的元素
	void Erase(Node* pos);//删除指定的节点
private:
	Node* _head;//头指针
	Node* _tail;//尾指针
};

ostream& operator<<(ostream& os, DouList& l)//输出运算符的重载
{
	Node* cur = l._head;
	while (cur)
	{
		os << cur->_data << "<=>";
		cur = cur->_next;
	}
	cout << "over";
	return os;
}

void DouList::PushBack(const DataType& d)
{
	Node* newNode = new Node(d);
	if (_head == NULL)
	{
		_head = newNode;
		_tail = _head;
	}
	else
	{
		_tail->_next = newNode;
		newNode->_prev = _tail;
		_tail = newNode;
	}
}

void DouList::PopBack()
{
	if (_head == NULL)
	{
		return;
	}
	if (_head == _tail)
	{
		delete _head;
		_head = NULL;
		_tail = NULL;
		return;
	}
	Node* del = _tail;
	_tail = _tail->_prev;
	_tail->_next = NULL;
	delete del;
}

void DouList::PushFront(const DataType& d)
{
	Node* newNode = new Node(d);
	if (_head == NULL)
	{
		_head = newNode;
		_tail = _head;
	}
	else
	{
		newNode->_next = _head;
		_head->_prev = newNode;
		_head = newNode;
	}

}

void DouList::PopFront()
{
	if (_head == NULL)
	{
		return;
	}
	if (_head == _tail)
	{
		delete _head;
		_head = NULL;
		_tail = NULL;
		return;
	}
	Node* del = _head;
	_head = _head->_next;
	_head->_prev = NULL;
	delete del;
}

Node* DouList::Find(const DataType& d)
{
	Node* cur = _head;
	while (cur)
	{
		if (cur->_data == d)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}

void DouList::Insert(Node* pos, const DataType& d)
{
	if (pos == NULL)
	{
		return;
	}
	Node* newNode = new Node(d);
	if (pos != _tail)//非尾节点插入
	{
		newNode->_next = pos->_next;
		newNode->_prev = pos;
		pos->_next = newNode;
	}
	else//尾节点插入
	{
		_tail->_next = newNode;
		newNode->_prev = _tail;
		_tail = newNode;
	}
}

void DouList::BubbSort()
{
	Node* cur = _head;
	Node* end = NULL;
	bool flag = true;
	while (cur->_next != end && flag)
	{
		flag = false;
		while (cur->_next != end && cur)
		{
			if (cur->_data > cur->_next->_data)
			{
				flag = true;
				swap(cur->_data, cur->_next->_data);
			}
			cur = cur->_next;
		}
		end = cur;
		cur = _head;
	}
}

void DouList::Reverse()
{
	Node* cur = _head;
	Node* newHead = NULL;
	Node* tmp = NULL;
	while (cur)
	{
		tmp = cur->_next;
		cur->_next = newHead;
		if (newHead)
		{
			newHead->_prev = cur;
		}
		newHead = cur;
		newHead->_prev = NULL;
		cur = tmp;
	}
	swap(_head, _tail);
}

void DouList::Remove(const DataType& d)
{
	if (_head == NULL)//无节点
	{
		return;
	}
	Node* cur = _head;
	while (cur)
	{
		if (cur->_data == d)
		{
			if (cur == _head)//第一个相等
			{
				PopFront();
				return;
			}
			else if (cur == _tail&& _head != _tail)//最后一个节点相等
			{
				PopBack();
				return;
			}
			else//其他节点
			{
				cur->_prev->_next = cur->_next;
				cur->_next->_prev = cur->_prev;
				delete cur;
				return;
			}
		}
		cur = cur->_next;
	}
}

void DouList::RemoveAll(const DataType& d)
{
	Node* cur = _head;
	bool flag = true;
	while (cur)
	{
		flag = true;
		if (cur->_data == d)
		{
			flag = false;
			cur = cur->_next;
			Remove(d);
		}
		if (flag)
		{
			cur = cur->_next;
		}
	}
}

void DouList::Erase(Node* pos)
{
	if (pos == NULL)//
	{
		return;
	}
	if (pos == _head)//删除第一个节点
	{
		PopFront();
		return;
	}
	if (pos == _tail)//删除最后一个节点
	{
		PopBack();
		return;
	}
	//非尾节点的删除
	pos->_next->_prev = pos->_prev;
	pos->_prev->_next = pos->_next;
}