练习 -- 使用双向链表来实现双向队列

1.题目：

使用一个双向链表来实现一个双向的队列，并且让队列具有以下的操作：

（1）判断队列是否为空

（2）得到双向队列中元素的个数

（3）向左端添加一个新元素

（4）向右端添加一个新元素

（5）从左端删除一个元素

（6）从右端删除一个元素

2.分析：

有了双向链表，我们就可以创建我们自己的双向队列，并且很容易地就能实现上面的操作

3.代码：

doublelist.hpp

#ifndef DOUBLELIST_HPP
#define DOUBLELIST_HPP

template<typename T>
class DoubleList
{
public:
DoubleList();
~DoubleList();
void insertAtHead(T item);  	//在表头插入节点
void insertAtTail(T item);		//在表尾插入节点
T deleteAtHead();				//在表头删除节点
T deleteAtTail();				//在表尾删除节点
bool isEmpty();					//判空
int size();						//得到元素的个数
private:
class Node            //内部节点类
{
public:
Node(T item) : next(nullptr), pre(nullptr), data(item){}
~Node(){}
T data;
Node* next;
Node* pre;
};
Node* first;
Node* tail;
int sizeOfList;
};

template<typename T>
DoubleList<T>::DoubleList() : first(nullptr), tail(nullptr), sizeOfList(0) {}

template<typename T>
DoubleList<T>::~DoubleList()
{
if (isEmpty())
{

}
else
{
while (first != nullptr)
{
Node* deleteNode = first;
first = first->next;
deleteNode->next = nullptr;
delete deleteNode;
}
}
}

template<typename T>
void DoubleList<T>::insertAtHead(T item)
{
if (isEmpty())           //如果表为空
{
Node* currentNode = new Node(item);
first = tail = currentNode;
}
else
{
Node* currentNode = new Node(item);
currentNode->next = first;
first->pre = currentNode;
first = currentNode;
}
sizeOfList++;
}

template<typename T>
void DoubleList<T>::insertAtTail(T item)
{
if (isEmpty())        // 如果表为空
{
Node* currentNode = new Node(item);
first = tail = currentNode;
}
else
{
Node* currentNode = new Node(item);
currentNode->pre = tail;
tail->next = currentNode;
tail = currentNode;
}
sizeOfList++;
}

template<typename T>
T DoubleList<T>::deleteAtHead()
{
if (isEmpty())        // 如果表为空
{
return nullptr;
}
else
{
T returnData = first->data;
Node* deleteNode = first;
first = first->next;
deleteNode->next = nullptr;
delete deleteNode;
sizeOfList--;
return returnData;
}

return nullptr;
}

//模版特化
template<>
int DoubleList<int>::deleteAtHead()
{
if (isEmpty())        // 如果表为空
{
return 0;
}
else
{
int returnData = first->data;
Node* deleteNode = first;
first = first->next;
deleteNode->next = nullptr;
delete deleteNode;
sizeOfList--;
return returnData;
}

return 0;
}

template<typename T>
T DoubleList<T>::deleteAtTail()
{
if (isEmpty())        // 如果表为空
{
return nullptr;
}
else
{
int returnData = tail->data;
Node* deleteNode = tail;
tail = tail->pre;
deleteNode->pre = nullptr;
delete deleteNode;
sizeOfList--;
return returnData;
}

return nullptr;
}

//模版特化
template<>
int DoubleList<int>::deleteAtTail()
{
if (isEmpty())        // 如果表为空
{
return 0;
}
else
{
int returnData = tail->data;
Node* deleteNode = tail;
tail = tail->pre;
deleteNode->pre = nullptr;
delete deleteNode;
sizeOfList--;
return returnData;
}

return 0;
}

template<typename T>
bool DoubleList<T>::isEmpty()
{
return sizeOfList == 0;
}

template<typename T>
int DoubleList<T>::size()
{
return sizeOfList;
}

#endif

deque.hpp

#ifndef DEQUE_HPP
#define DEQUE_HPP

#include "doublelist.hpp"

template<typename T>
class Deque
{
public:
Deque();					//创建空的双向队列
~Deque();
void pushLeft(T item);    //向左端添加一个新元素
void pushRight(T item);   //向右端添加一个新元素
T popLeft();			  //从左端删除一个元素
T popRight();			  //从右端删除一个元素
int size();				  //双向队列中的元素数量
bool isEmpty();			  //双向队列是否为空
private:
DoubleList<T> myList;
};

template<typename T>
Deque<T>::Deque() : myList(){}

template<typename T>
Deque<T>::~Deque()
{

}

template<typename T>
int Deque<T>::size()
{
return myList.size();
}

template<typename T>
void Deque<T>::pushLeft(T item)
{
myList.insertAtHead(item);
}

template<typename T>
void Deque<T>::pushRight(T item)
{
myList.insertAtTail(item);
}

template<typename T>
T Deque<T>::popLeft()
{
return myList.deleteAtHead();
}

template<typename T>
T Deque<T>::popRight()
{
return myList.deleteAtTail();
}

template<typename T>
bool Deque<T>::isEmpty()
{
return myList.isEmpty();
}

#endif

main.cpp

#include <iostream>
#include <string>
#include "deque.hpp"

using namespace std;

int main(int agrc, char** argv)
{
Deque<int> deque;
for(int i = 0; i != 5; ++i)
{
deque.pushLeft(i);
}

for (int i = 5; i != 0; --i)
{
deque.pushRight(i);
}

int size = deque.size();
for (int i = 0; i != size; ++i)
{
//cout << deque.popLeft() << " ";
cout << deque.popRight() << " ";
}
cout << endl;

return 0;
}

4.总结：双向队列还能使用动态数组来实现，但是使用数组的话，在左端插入元素的操作所需的时间跟集合大小相关，会花费多余的时间，所以我们还是使用双向链表来实现双向队列。