数据结构 队列 （数组）

队列：一种先进先出，在一端进行入队操作，另一端进行出队操作的一种受限制的线性表；

既然队列和栈类似，都是一种受限制的线性表，那么它们都应该有判空，判满，压入值，提取值，删除值等一些基本操作，不同的是，队列限制在两端进行不同的操作，所有队的数据成员应该有一个指示队头和一个指示队尾的两个指针，加上存储元素的数组组成；

写出队的类如下：

//静态数组的 循环队类
typedef int QueueElement;
#define maxs 100
class Queue
{
	public :
		Queue ();
		bool empty () const;
		bool full () const;
		void enqueue (const QueueElement & value);
		void display (ostream &out) const;
		void dequeue ();
		QueueElement front () const;
	private :
		int myFront;
		int myBack;
		QueueElement myArray[maxs];
};

//动态数组的 循环队类

typedef int QueueElement;
class Queue
{
	public :
		Queue (int number=10);
		~Queue ();
		Queue (const Queue & original);
		const Queue & operator = (const Queue &right);
		bool empty () const;
		bool full () const;
		void enqueue (const QueueElement & value);
		void dequeue ();
		QueueElement front () const;
	private :
		int myFront;
		int myBack;
		int myCount;  //队的容量
		QueueElement * myArray;
};

现在考虑判断队列是否为空的基本操作，如果队列包含一个元素，则该元素必然是在数组的 myFront 位置，而 myBack 则在 其 后 一个位置；如果这个元素被删除了，myFront 后移一位，此时，myFront==myBack 一定成立；所有判断对列是否为空则只需判断 ：myFront==myBack；

但是，由循环队列可知，当队列满的时候，也一定是 myFront==myBack 成立的时候；不过，我们假设一个循环队列还有一个空位，此时，myFront 和 myBack 必然相差一个单位；那么当myBack'向后移动的时候就会和 myFront 相等，此时，队列就被填满了，故可以通过： myFront==(myBack +1) % myCount  是否相等来判断队列是否已满；

其他基本操作见具体代码：

Queue::~Queue () { delete [] myArray;}

//复制运算符
const Queue & Queue::operator = (const Queue & right)
{
	if (this!=&right)
	{
		if (myCount != right.myCount)
		{
			delete [] myArray;
			myCount = right.myCount;
			myArray = new (nothrow) QueueElement[myCount];
			if (myArray==0)
				cerr << "ERROR\n";
			else
			{
				myFront=right.myFront;
				myBack=right.myBack;
				for (int i=myFront; i!=myBack; i=(i+1)%myCount)
					myArray[i] = right.myArray[i];
			}
		}
	}
	return *this;
}
//复制构造函数
Queue::Queue (const Queue & original) : myFront(original.myFront),myBack(original.myBack),myCount(original.myCount)
{
	myArray = new (nothrow) QueueElement[myCount];
	if (myArray)
	{
		for (int i=myFront; i!=myBack; i=(i+1)%myCount)
			myArray[i] = original.myArray[i];
	}
	else
	{
		cerr<<"内存分配出错;\n";
		exit(EXIT_FAILURE);
	}
}

Queue::Queue (int number) : myFront(0),myBack(0)
{
	if (number < 0)
	{
		cerr <<"队容量出错;\n";
		exit(EXIT_FAILURE);
	}
	else
	{
		myArray = new (nothrow) QueueElement[number];
		if (myArray)
			myCount = number;
		else
		{
			cerr<<"内存分配出错;\n";
			exit(EXIT_FAILURE);
		}
	}
}

bool Queue::empty () const
{
	return myFront == myBack;
}

bool Queue::full () const
{
	return myFront == (myBack+1) % myCount;
}

void Queue::enqueue (const QueueElement & value)
{
	if (!full())
	{
		int newBack = (myBack+1) % myCount;
		myArray[myBack] = value;
		myBack = newBack;
	}
	else
	{
		cerr <<"队满;\n";
		exit(EXIT_FAILURE);
	}
}

void Queue::dequeue ()
{
	if (!empty ())
		myFront = (myFront+1) % myCount;
	else
	{
		cerr <<"队空;\n";
		exit(EXIT_FAILURE);
	}
}

QueueElement Queue::front () const
{
	if (empty ())
	{
		cerr <<"队空;\n";
		exit(EXIT_FAILURE);
	}
	else
		return myArray[myFront];
}

测试代码：

int main ()
{
	Queue s(10);
	cout << "created a queue,Empty ?\n"<<(s.empty() ?"YES":"NO") <<endl;
	cout << "Now,Full ?\n"<<(s.full() ?"YES":"NO") <<endl;
	cout << "How many number want to enter the queue?\n";
	int num;
	cin >> num;
	for (int i=0;i<num;i++)
	{
		cout << i+10 <<" enter the queue\n";
		s.enqueue (i+10);
	}
	cout << "Now,Empty ?\n"<<(s.empty() ?"YES":"NO") <<endl;
	cout << "Now,Full ?\n"<<(s.full() ?"YES":"NO") <<endl;
	cout << "the queue Front :  "<<s.front () << endl;
	for (int i=0;i<num;i++)
	{
		cout << "Now,Delete the :  "<<s.front()<<endl;
		s.dequeue ();
	}
	cout << "Now,Empty ?\n"<<(s.empty() ?"YES":"NO") <<endl;
	cout << "Now,Full ?\n"<<(s.full() ?"YES":"NO") <<endl;
	return 0;
}