数据结构（Java语言）——Queue简单实现

和栈类似，队列queue也是表。然而，使用队列时插入在一端进行而删除在另一端进行。

队列的基本操作是enqueue（入队）和dequeue（出队），入队是在队尾rear（表的末端）插入一个元素，出队是删除在队头front（表的开头）的元素。

和栈一样，对于队列而言任何表的实现都可以，而且对于每种操作，链表实现和数组实现都是快速的O(1)时间。下面主要讨论队列的循环数组实现。

对于每一个队列数组结构，我们保留一个数组theArray[]以及位置front和rear，它们表示队列的两端。我们还要记录实际存在于队列中的元素个数currentSize。为使一个元素x入队，我们执行enqueue()使currentSize和rear增1，然后置theArray[rear]=x。为使元素出队列，我们置返回值为theArray[front]，并且currentSize减1，然后使front加1。以下是相关代码实现：

import java.util.Iterator;
import java.util.NoSuchElementException;

public class MyQueue<AnyType> implements Iterable<AnyType> {
	private static final int DEFAULT_CAPACITY = 10;
	private AnyType[] theArray; // 以数组存放数据
	private int currentSize; // 当前队列的长度，非数组长度
	private int front; // 队头
	private int rear; // 队尾

	/**
	 * 构造函数自动执行clear()函数
	 */
	public MyQueue() {
		clear();
	}

	/**
	 * 分配内存，初始化各成员变量
	 */
	public void clear() {
		ensureCapacity(DEFAULT_CAPACITY);
		currentSize = 0;
		front = rear = 0;
	}

	/**
	 * 返回当前数组长度
	 * 
	 * @return 数组长度
	 */
	public int size() {
		return theArray.length;
	}

	/**
	 * 当前队列是否满
	 * 
	 * @return
	 */
	public boolean isFull() {
		return currentSize == size();
	}

	/**
	 * 当前队列是否空
	 * 
	 * @return
	 */
	public boolean isEmpty() {
		return currentSize == 0;
	}

	/**
	 * 根据参数确定数组长度
	 * 
	 * @param newCapacity
	 *            新的大小
	 */
	@SuppressWarnings("unchecked")
	public void ensureCapacity(int newCapacity) {
		// 第一次（数组未分配）直接分配内存
		if (theArray == null) {
			theArray = (AnyType[]) new Object[newCapacity];
			return;
		}
		// 参数小于当前长度直接返回
		if (newCapacity < size()) {
			return;
		}
		// 数组扩充时将原数据复制到新分配的数组里
		AnyType[] old = theArray;
		theArray = (AnyType[]) new Object[newCapacity];
		for (int i = front; i < front + old.length; i++) {
			theArray[i - front] = old[i % old.length];
		}
		// 重新赋值各变量
		front = 0;
		rear = old.length - 1;
		currentSize = old.length;
	}

	/**
	 * 入队操作
	 * 
	 * @param value
	 *            入队元素
	 */
	public void enqueue(AnyType value) {
		// 检查队列是否满
		if (isFull()) {
			ensureCapacity(size() * 2);
		}
		// 第一次入队时队尾无数据，直接赋值。之后队尾先加一取余再赋值
		if (theArray[rear] != null) {
			rear = (rear + 1) % size();
		}
		theArray[rear] = value;
		currentSize++;
	}

	/**
	 * 出队操作
	 * 
	 * @return 出队元素
	 */
	public AnyType dequeue() {
		// 若队列空则无法出队
		if (isEmpty()) {
			throw new NullPointerException();
		}
		// 出队操作
		currentSize--;
		AnyType value = theArray[front];
		theArray[front] = null;
		front = (front + 1) % size();
		return value;
	}

	/**
	 * 实现Iterable接口
	 */
	public Iterator<AnyType> iterator() {
		return new QueueIterator();
	}

	private class QueueIterator implements Iterator<AnyType> {

		private int current = 0;

		public boolean hasNext() {
			return current < size();
		}

		public AnyType next() {
			if (!hasNext()) {
				throw new NoSuchElementException();
			}
			return theArray[current++];
		}

	}

	public static void main(String[] args) {
		MyQueue<Integer> queue = new MyQueue<Integer>();
		Iterator<Integer> iterator1 = queue.iterator();
		Iterator<Integer> iterator2 = queue.iterator();
		queue.enqueue(1);
		queue.enqueue(2);
		queue.enqueue(3);
		queue.enqueue(4);
		queue.enqueue(5);
		queue.enqueue(6);
		queue.enqueue(7);
		queue.enqueue(8);
		queue.enqueue(9);
		queue.enqueue(10);
		queue.dequeue();
		queue.dequeue();
		queue.dequeue();
		queue.dequeue();
		queue.enqueue(11);
		queue.enqueue(12);
		System.out.println("队列未超出容量时结果：");
		while (iterator1.hasNext()) {
			System.out.print(iterator1.next() + " ");
		}
		System.out.println("\n队列超出容量时结果：");
		queue.enqueue(13);
		queue.enqueue(14);
		queue.enqueue(15);
		while (iterator2.hasNext()) {
			System.out.print(iterator2.next() + " ");
		}
	}
}

执行结果：

队列未超出容量时结果：
11 12 null null 5 6 7 8 9 10 
队列超出容量时结果：
5 6 7 8 9 10 11 12 13 14 15 null null null null null null null null null