数据结构之队列的顺序存储

一、队列

队列是线性表的一种特殊形式，遵循“先进先出”的原则。队列中一般包含两个指针：一个指针（front）用来指向队首，另一个指针（rear）用来指向队尾。队列的操作如下图的a~i所示。

上图中我们假设队列的最大长度为4。图a表示队列为空队，此时队首和队尾都是指向-1的；当元素A进队后（图b），队首不变，队尾指向元素A（下标为0）；当元素B进队后（图c），队首不变，队尾指向元素B（下标为1）；当元素C进队后（图d），队首不变，队尾指向元素C（下标为2）；当元素D进队后（图e），队首不变，队尾指向元素D（下标为3），此时队列为满队，不允许再有元素入队了；当元素A出队时（图f），队首右移一个元素位置，队尾不变；以此类推，当元素D出队时（图i），队首右移一个元素位置，此时队首和队尾相遇了，表示队列为空。

总结：

1.队列是一种特殊的线性表，遵循“先进先出，后进后出”的原则，就跟我们在火车站排队买票一样；

2.队列为空时，front与rear指向同一位置；

3.队列为满队时，rear指向数组的最后一个元素；

4.采用普通的顺序存储队列时，队列存在“虚满”的情况，即rear指向数组的最后一个元素时，队列不一定是真正意义上的满队，有可能若干队首元素已经出队，如图f~h所示。为了防止“虚满”情况发生，可以采用以下两种方式：（1）队首元素出队后，将数组中的所有元素向前移动一格；（2）采用循环队列的方式。方式一的时间复杂度为O(n)，方式二的时间复杂度为O(1)，因此更多采用循环队列的方式来降低队列算法复杂度。

普通队列的实现代码如下所示。在队列类中，封装了队列构造、判断队列是否为空、判断队列是否为满队、入队、出队、获取队首元素等操作的方法。

public class Queue {
	private Object[] a;
	private int length = 100;
	private int front = -1;
	private int rear = -1;
	
	/**
	 * 构造函数
	 */
	public Queue() {
		a = new Object[length];
	}
	/**
	 * 重载构造函数
	 * 
	 * @param length 初始化队列的长度
	 */
	public Queue(int length) {
		this.length = length;
		a = new Object[length];
	}
	
	/**
	 * 判断队列是否为空
	 * 
	 * @return 如果队列为空，返回true；否则，返回false
	 */
	public boolean isEmpty() {
		return front == rear;
	}
	
	/**
	 * 判断队列是否为满队。该函数并不能真正判断队列是否已满，因为有可能一些元素已出队，
	 * 因此在队首存在空缺。如果需要判断真正的队满，请参见循环队列中的判断队满函数。
	 * 
	 * @return 如果队列为满队，返回true；否则，返回false
	 */
	public boolean isFull() {
		return rear == length - 1;
	}
	
	/**
	 * 获取队列中的元素，需要判断队列是否为空队
	 * 
	 * @return 如果队列为空，返回null；否则，返回队首元素
	 */
	public Object get() {
		return isEmpty() ? null : a[front + 1];
	}
	
	/**
	 * 将队列中的队首元素出队，需要判断队列是否为空队
	 * 
	 * @return 如果队列为空，返回null；否则，返回队首元素
	 */
	public Object outQueue() {
		return isEmpty() ? null : a[++front];
	}
	
	/**
	 * 向队尾添加元素item，需要判断队列是否为满队
	 * 
	 * @param item 向队尾中插入的元素
	 * @return 如果队满，返回false；否则，返回true
	 */
	public boolean inQueue(Object item) {
		if(isFull()) {
			return false;
		} else {
			a[++rear] = item;
			return true;
		}
	}
}

二、循环队列

循环队列是队列的顺序存储结构的一种优化，主要是为了解决队列“虚满”的问题，提升队列空间的使用效率。循环队列采用存储结构同样是数组，只是将数组看成是一个环形结构而已。如下图所示。

数组A[0...N]是一个具有N+1个元素的数组，我们假设该数组的头（0位置）和尾（N位置）是相接的。当队列中不存在任何元素时，队首（front）和队尾（rear）均指向数组下标为0的结点；当有元素A入队时，先将队尾（rear）右移一个位置至下标1，并将下标1位置写入元素A；当有元素出队时，先将队首（front）右移一个位置至下标1，并获取下标1位置的元素；当位置N处已经存在元素时，此时如果还有元素要入队，则判断数组下标为0的位置是否为队首，如果是，则表明队满了，如果不是，则将需要入队的元素写入下标0的位置。以此类推。

不难看出：循环队列的N+1个位置中，队首所指位置始终是不存在元素的，但不可否认，这一个位置的牺牲还是很有必要滴。

循环队列的实现代码如下。同样，代码中封装了判断队空、判断队满、入队、出队、获取队首元素等方法。

public class CycleQueue {
	private Object[] a;
	private int length = 100;
	private int front = 0;
	private int rear = 0;
	
	/**
	 * 构造函数
	 */
	public CycleQueue() {
		a = new Object[length];
	}
	/**
	 * 重载构造函数
	 * 
	 * @param length 初始化队列的长度
	 */
	public CycleQueue(int length) {
		this.length = length;
		a = new Object[length];
	}
	
	/**
	 * 判断队列是否为空
	 * 
	 * @return 如果队列为空，返回true；否则，返回false
	 */
	public boolean isEmpty() {
		return front == rear;
	}
	
	/**
	 * 判断队列是否为满队
	 * 
	 * @return 如果队列为满队，返回true；否则，返回false
	 */
	public boolean isFull() {
		return (rear + 1) % length == front;
	}
	
	/**
	 * 获取队列中的元素，需要判断队列是否为空队
	 * 
	 * @return 如果队列为空，返回null；否则，返回队首元素
	 */
	public Object get() {
		return isEmpty() ? null : a[(front + 1) % length];
	}
	
	/**
	 * 将队列中的队首元素出队，需要判断队列是否为空队
	 * 
	 * @return 如果队列为空，返回null；否则，返回队首元素
	 */
	public Object outQueue() {
		if(isEmpty()) {
			return null;
		} else {
			front = (front + 1) % length;
			return a[front];
		}
	}
	
	/**
	 * 向队尾添加元素item，需要判断队列是否为满队
	 * 
	 * @param item 向队尾中插入的元素
	 * @return 如果队满，返回false；否则，返回true
	 */
	public boolean inQueue(Object item) {
		if(isFull()) {
			return false;
		} else {
			rear = (rear + 1) % length;
			a[rear] = item;
			return true;
		}
	}
}