算法（9）队列

        队列是一种先进先出（first in first out）的数据结构，重要的元素有 头，尾， 队列长度。队列的操作基本有四种，验空（isEmpty），验满（isFull），出队（deQueue）,入队（enQueue）。

        实现队列有两种方法，数组和链表。这里数组的程序是我自己写的，链表的则是参考《C++ primer plus》六版P471上的代码。

        关于用数组实现队列，可以将数组想象成一个首尾相接的环，head和tail之间的为队列，队列在这个环上移动。

        用数组实现的代码如下：

#include <iostream>

using namespace std;

class Queue
{
	private:
		int head,tail;
		int *q,len;
		//int item;
	public:
		Queue(int);
		~Queue();
		bool isFull() const;
		bool isEmpty() const;
		bool enQueue(int);
		bool deQueue(int &);
		void show() const;
};


/**************************** 以下为类的实现****************************/

Queue::Queue(int _len=10)
{
	head=tail=0;
	len=_len;
	q=new int(len);
}

Queue::~Queue()
{
	delete q;
}

bool Queue::isFull() const
{
	if((head==0&&tail==len-1)||(head==tail+1))
		return true;
	else
		return false;
}

bool Queue::isEmpty() const
{
	if(head==tail)
		return true;
	else
		return false;
}

bool Queue::enQueue(int x)
{
	if(isFull())
		return false;
	else
	{
		q[tail]=x;
		if(tail==len-1)
			tail=0;
		else
			tail++;
	}
}

bool Queue::deQueue(int &x)
{
	if(isEmpty())
		return false;
	else
	{
		x=q[head];
		if(head==len-1)
			head=0;
		else
			head++;
		return true;
	}
}

void Queue::show() const
{
	if(tail>=head)
		for(int i=head;i<tail;i++)
			cout<<q[i]<<" ";
	else
	{
		for(int i=head;i<len;i++)
			cout<<q[i]<<" ";
		for(int i=0;i<tail;i++)
			cout<<q[i]<<" ";
	}
}

//**************************************************

int main()
{
	int x;
	Queue queue(5);
	queue.enQueue(10);
	queue.enQueue(20);
	queue.enQueue(40);
	queue.enQueue(50);
	queue.show();
	queue.deQueue(x);
	cout<<'\n'<<x<<endl;
	queue.show();
	queue.deQueue(x);
	cout<<'\n'<<x<<endl;
	queue.show();
	return 0;
}

        用链表实现如下：

#include <iostream>

using namespace std;

class Queue
{
	private:
		struct Node
		{
			int item;
			struct Node *next;
		};
		enum
		{
			Q_SIZE=10   //默认构造时需要
		};
		Node *head;
		Node *tail;
		int items;  //队列内现有元素的个数 
		const int qsize;//队列的最大长度
		Queue(const Queue &q):qsize(0) 
		{
			
		}  //默认构造长度为0
		Queue & operator=(const Queue & q)  //重载=这个运算符
		{
			return *this;
		}
		
	public：
		Queue(int qs=Q_SIZE);
		~Queue();
		bool isEmpty() const;
		bool isFull() const;
		int queueCount() const;
		bool enQueue(const int & item);
		bool deQueue(int &item);		
};


/**************************** 以下为类的实现****************************/

Queue::Queue(int qs):qsize(qs)
{
	head=tail=NULL;
	items=0;
}

Queue::~Queue()
{
	Node *temp;
	while(head!=NULL)
	{
		temp=head;
		head=head->next;  //从头开始释放每一个节点
		delete temp;
	}
}

bool Queue::isEmpty() const
{
	return items==0;
}

bool Queue::isFull() const
{
	return items==qsize;
}

int Queue::queueCount() const
{
	return items;
}

bool Queue::enQueue(const int &item)
{
	if(isFull())
		return false;
	Node * add=new Node;
	add->item=item;
	add->next=NULL;
	items++;
	
	if(head==NULL)  //队列空
		head=add;
	else
		tail->next=add;
	tail=add;
	return true;
}

bool Queue::deQueue(int &item)
{
	if(isEmpty())
		return false;
	
	item=head->item;
	items--;
	Node *temp=head;
	head=head->next;
	delete temp;
	
	if(items==0)  //队内无元素
		tail=NULL;
	return true;
}