一些常用的容器类模板构建——队列

基本概述

• 队列（queue）是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，称为出队；而在表的后端（rear）进行插入操作，称为入队。
• 和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为对头。队列中没有元素时称为空队列。
• 队列是一种先进先出（FIFO）结构。

模板中的嵌套结构与队列

template<class Item>
class QueueTP
{
private:
	enum{Q_SIZE=10};
	class Node      //定义一个嵌套类Node
	{
	public:
		Item item;
		Node * next;
		Node(const Item & i):item(i),next(0){ } //该构造函数创建了一个新结点，并将next指针置为空
	}；
	Node * front;
	Node * rear;
	int items;  //队列中的元素
	const int qsize;  //队列的大小
	QueueTP(const QueueTP & q) {return *this; }
public:
	QueueTP(int qs=Q_SIZE); 
	~QueueTP();  //析构函数，释放队列
	bool isempty() const {return items==0; }
	bool isfull() const {return items==qsize; }
	int queuecount() const {return items; }
	bool enqueue(const Item & item);  //入栈
	bool dequeue(Item & item);  //出栈
}；

在一个类中声明的类被称为嵌套类，对类进行嵌套不创建类成员，而是定义了一种类型，该类型仅在包含嵌套类声明的类中有效。
下面进行类方法的定义

template<class Item>
QueueTP<Item>::QueueTP(int qs):qsize(qs)
{
	front=rear=0;
	items=0;
}

带一个参数的构造函数，创建一个空队列

template<class Item>
QueueTP<Item>::~QueueTP()
{
	Node * temp;
	while(front!=0)
	{
		temp=front;
		front=front->next;
		delete temp;
	}
}

析构函数将该队列重新变成一个空队列，若队列不为空，则创建一个临时结点，将队头赋给临时结点，将队头的下一个结点变成队头，然后删除临时指针，遍历进行，直到队头为空。

template<class Item>
bool QueueTP<Item>::enqueue(const Item & item)
{
	if(isfull)
		return false;
	Node * add = new Node(item); //创建一个结点
	items++;
	if(front==0)
		front=add;
	else
		rear->next=add;
	rear=add;
	return true;
}
template<class Item>
bool QueueTp<Item>::dequeue(Item & item)
{
	if (isempty())
		return false;
	item = front->item;
	items--;
	Node * temp = front;
	front = front->next;
	delete temp;
	if (items == 0)
		return 0;
	return true;
}

压栈和出栈操作，压栈操作时要新建一个结点，若原队列为空，则该结点为队头，若不为空，则该结点为队尾的下一个结点；出栈操作时与析构函数类似，创建一个临时结点保存队头，然后将队头的下一个结点变为队头，最后删除临时结点。