【C++数据结构实验】基于双链表实现双端队列，Deque的面向对象链表实现。

今天写了个基于双链表的双端队列，据说考研常考到，那下面就来具体看看吧！

基于双链表的双端队列

首先我们要知道什么是双端对列：
deque 即双端队列。是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出。
双端队列是限定插入和删除操作在表的两端进行的线性表。这两端分别称做端点1和端点2。也可像栈一样，可以用一个铁道转轨网络来比喻双端队列。在实际使用中，还可以有输出受限的双端队列（即一个端点允许插入和删除，另一个端点只允许插入的双端队列）和输入受限的双端队列（即一个端点允许插入和删除，另一个端点只允许删除的双端队列）。而如果限定双端队列从某个端点插入的元素只能从该端点删除，则该双端队列就蜕变为两个栈底相邻的栈了。
下面来看这张基于双链表实现的双端对列图片：

可以看到在本例中使用port_front和port_rear分别表示双端对列具有的两个端口，这是我们只需定义基于这两个端口的头插、头删、尾插、尾删即可实现一个简单的双端对列。在调用时如果只使用头插（本例为push（））、头删（pop（）），即限定仅在port_front端口进行插删操作，我们就实现了一个简单的栈功能。同理尾部的插删为inject（）和eject（），仅使用这两个函数又成功定义了一个基于port_rear端口的栈。同理，调用其中某两个函数也可以实现其他功能，比如用仅用push（）和eject（）就实现一个队列，不再赘述。
下面看一下具体实现方法：
这是push的实现方法，inject与之类似：

这是pop的实现，与栈的弹出功能相同，eject与之类似：

同时为了Deque中数据可获取我们还需要写一个retrieve（）来实现返回端口元素，但两个端口指向不同，所以需要定义两个返回函数分别返回前后端口的数据值，分别为：retrieve_front()和retrieve_rear()，其实现也很简单，只需使用port_front->entry;即可。
同时还应加入析构，拷贝构造，赋值=重载等，即可完成了。

具体代码可能和上述讲解有所不同，但基本实现思路是一致的，该版本进行多次优化，具有较强容错性。
下面来看具体代码吧：

#pragma once
#ifndef __DLIST_H__
#define __DLIST_H__
#include 
using namespace std;
class emptyList {
     

};
template <typename T>
class Dlist {
     
public:
	bool isEmpty() const;
	void insertFront(T *o);//前插
	void insertBack(T *o);//尾插
	T *removeFront();//前删
	T *removeBack();//尾删
	Dlist();//构造函数
	Dlist(const Dlist &l);//拷贝构造
	Dlist &operator=(const Dlist &l);//等号重载
	~Dlist();//析构
private:
	struct node {
     
		node *next;
		node *prev;
		T *o;
	};
	node *first;
	node *last;
	void makeEmpty();
	void removeAll();
	void copyAll(const Dlist &l);
};
template<typename T>
Dlist<T>::Dlist() {
     
	first = last = NULL;
}
template<typename T>
bool Dlist<T>::isEmpty()const {
     
	return first == NULL;
}
template<typename T>
void Dlist<T>::makeEmpty() {
     
	first = last = NULL;
}
template<typename T>
void Dlist<T>::removeAll() {
     
	node *copy;
	while (first->next != NULL) {
     
		copy = first->next;
		delete first;
		first = copy;
	}
}
template<typename T>
void Dlist<T>::copyAll(const Dlist &l) {
     
	if (first != NULL) {
     
		removeAll();
		makeEmpty();
	}
	if (l.first == NULL) {
     
		first = last = NULL;
	}
	else {
     
		node *copy = l.first;
		node *first_one = new node;
		first_one->next = first_one->prev = NULL;
		T *copyo = new T(*copy->o);
		first_one->o = copyo;
		first = last = first_one;
		while (copy->next != NULL) {
     
			copy = copy->next;
			node *new_one = new node;
			int *copyo = new int(*copy->o);
			new_one->o = copyo;
			new_one->prev = last;
			new_one->next = NULL;
			last->next = new_one;
			last = new_one;
		}
	}
}
template<typename T>
Dlist<T>::~Dlist() {
     
	if (first != NULL) {
     
		removeAll();
		makeEmpty();
	}

}
template<typename T>
Dlist<T>::Dlist(const Dlist &l) {
     
	copyAll(l);
}
template<typename T>
Dlist<T>& Dlist<T>::operator = (const Dlist &l) {
     
	Dlist copy = Dlist(l);
	this->first = copy.first;
	this->last = copy.last;
	return *this;
}
template<typename T>
void Dlist<T>::insertFront(T *o) {
     
	node *new_one = new node;
	if (new_one == NULL)
		throw "OverFlow!";
	T *copyo = new T(*o);
	new_one->o = copyo;
	if (isEmpty()) {
     
		new_one->next = NULL;
		new_one->prev = NULL;
		first = last = new_one;
	}
	else {
     
		first->prev = new_one;
		new_one->next = first;
		new_one->prev = NULL;
		first = first->prev;
	}
}
template<typename T>
void Dlist<T>::insertBack(T *o) {
     
	node *new_node = new node;
	if (new_node == NULL)
		throw "OverFlow!";
	T *copyo = new T(*o);
	new_node->o = copyo;
	if (isEmpty()) {
     
		new_node->next = new_node->prev = NULL;
		first = last = new_node;
	}
	else {
     
		last->next = new_node;
		new_node->prev = last;
		new_node->next = NULL;
		last = last->next;
	}
}
template<typename T>
T *Dlist<T>::removeBack() {
     
	if (isEmpty())
		return NULL;
	T *copy;
	node *copy_node = new node;
	copy = last->o;
	if (first == last) {
     
		delete first;
		first = last = NULL;
		return copy;
	}
	else {
     
		copy_node = last->prev;
		copy_node->next = NULL;
		last->prev = NULL;
		delete last;
		last = copy_node;
		return copy;
	}
}
template<typename T>
T *Dlist<T>::removeFront() {
     
	if (isEmpty())
		return NULL;
	T *copy;
	node *copy_node;
	copy = first->o;
	if (first == last) {
     
		delete first;
		first = last = NULL;
		return copy;
	}
	else {
     
		copy_node = first->next;
		copy_node->prev = NULL;
		first->next = NULL;
		delete first;
		first = copy_node;
		return copy;
	}
}
#endif /* __DLIST_H__ */

最后我们使用该类看看具体效果如何：
以下是main（）函数内容：

#include"Dlist.h"
#include
int main() {
     
	cout << "使用前插依次插入5，3，2到l中....."<<endl<<"前删输出结果：";
	Dlist<int> l;
	int *a = new int(5);
	int *b = new int(3);
	int *c = new int(2);
	l.insertFront(a);
	l.insertFront(b);
	l.insertFront(c);
	cout <<"\t"<< *l.removeFront() << "\t";
	cout << *l.removeFront() << "\t";
	cout << *l.removeFront() << "\t";
	cout << endl <<"使用前插依次插入5，3，2到l中....."<<endl<< "尾删输出结果：";
	l.insertFront(a);
	l.insertFront(b);
	l.insertFront(c);
	cout <<"\t"<< *l.removeBack() << "\t";
	cout << *l.removeBack() << "\t";
	cout << *l.removeBack() << "\t";
	cout << endl;
	cout << "使用尾插依次插入5，3，2到l中.....则尾删的输出结果应为：2  3  5" << endl;
	l.insertBack(a);
	l.insertBack(b);
	l.insertBack(c);
	cout << "利用拷贝构造函数构造l1，被拷贝对象为上述对象。。。" << endl;
	Dlist<int> l1(l);
	cout << "l1的尾删输出结果：" << "\t";
	cout << *l1.removeBack() << "\t";
	cout << *l1.removeBack() << "\t";
	cout << *l1.removeBack() << "\t";
	cout << endl;
	cout << "使用尾插依次插入5，3，2到l中.....则尾删的输出结果应为：2  3  5" << endl;
	l.insertBack(a);
	l.insertBack(b);
	l.insertBack(c);
	cout << "重载运算符检验，使l2等于上述对象。。。" << endl;
	Dlist<int> l2=l;
	cout << "l2的尾删输出结果：" << "\t";
	cout << *l2.removeBack() << "\t";
	cout << *l2.removeBack() << "\t";
	cout << *l2.removeBack() << "\t";
	cout << endl;
	system("pause");
}```
好了双端队列就实现好了，欢迎讨论指正，感谢你的阅读！