通過學習自定義佇列，瞭解佇列的資料結構。

首先寫一個佇列的介面，描述其具有的基本功能。Queue.java

然後寫一個介面的實現類，這只是其中一種實現方式，為迴圈佇列。LoopQueue.java

最後寫一個測試類，測試自定義陣列佇列的效果。Test.java

在 自定義佇列（1）：陣列佇列 這篇文章中，陣列佇列的dequeue（）方法的時間複雜度為O(n)，這是因為，陣列佇列中，每當取出隊頭元素，就意味著整個陣列的前移。

而本篇的迴圈佇列，對dequeue（）方法，只是將front指標後移，所以時間複雜度為O(1)。大大提高了效率。

知識點：

1.  頭指標 front指向第一個元素。

2.尾指標tail指向最後一個元素的下一個位置。

3.判斷佇列為空的條件：tail=front

4.為防止佇列滿時，也出現tail=front的情況，所以迴圈佇列會浪費一個空間，什麼也不儲存。

5.則判斷佇列是否滿的條件為： (tail+1)% data.capacity=front.這裡的data.capacity指佇列的容量（不包括浪費的那一個空間）

6.由於是迴圈佇列，一定要注意   （任意+1）% data.capacity 這種表達。
 

LoopQueue.java的程式碼中：

1.巧用： （任意+1）% data.capacity 這種表達！

2.在resize（）方法、toString（）方法中的兩個for迴圈都是遍歷迴圈陣列的。是等價的。

Queue.java：

package Queue;

public interface Queue<E> {
	/**
	 * 獲取佇列中資料的大小
	 * @return
	 */
	int getSize();
	/**
	 * 判斷佇列是否為空
	 * @return
	 */
    boolean isEmpty();
    /**
     * 在隊尾插入元素
     * @param e
     */
    void enqueue(E e);
    /**
     * 在隊頭刪除元素
     * @return
     */
    E dequeue();
    /**
     * 檢視隊頭元素
     * @return
     */
    E getFront();
}
 

LoopQueue.java：

package Queue;

public class LoopQueue<E> implements Queue<E>{
	private E[] data;
	private int front;//指向隊頭的指標
	private int tail;//指向隊尾的下一個元素的指標
	private int size;//當前迴圈佇列裡資料的大小
	/**
	 * 帶參建構函式，自定義初始容量
	 * @param capacity
	 */
	public LoopQueue(int capacity) {
		//之所以加1，是因為迴圈佇列要浪費一個空間，以避免佇列滿時，頭指標=尾指標。
		//因為這時，與佇列為空的判斷條件相等。
		//以下，所有加1的原因都是如此。
		data=(E[])new Object[capacity+1];
		front=0;
		tail=0;
		size=0;
	}
	/**
	 * 無參建構函式，初始容量為10
	 */
	public LoopQueue() {
		this(10);
	}
	/**
	 * 返回佇列中資料的大小
	 */
	@Override
	public int getSize() {
		
		return size;
	}
	/**
	 * 自定義方法，返回迴圈佇列的容量大小
	 * @return
	 */
	public int getCapacity() {
		return data.length-1;
	}
	/**
	 * 判斷佇列是否為空
	 */
	@Override
	public boolean isEmpty() {
		
		return front==tail;
	}
	/**
	 * 插入隊尾
	 */
	@Override
	public void enqueue(E e) {
		if((tail+1)%data.length==front) {//判斷佇列是否滿
			resize(getCapacity()*2);
		}
		data[tail]=e;
		tail=(tail+1)% data.length;
		size++;
	}
	/**
	 * 自定義方法。
	 * 動態擴容
	 * @param i
	 */
	private void resize(int newCapacity) {
		E[] newData=(E[]) new Object[newCapacity]; 
		//擴容後，從0位置填充。
		for(int i=0;i<size;i++) {
			newData[i]=data[(front+i)%data.length];
		}
		data=newData;
		front=0;
		tail=size;
		//size不變
	}
	/**
	 * 取出隊頭
	 */
	@Override
	public E dequeue() {
		if(isEmpty()) {
			throw new IllegalArgumentException("空佇列，不可取出隊頭");
		}
		E e=data[front];
		front=(front+1)%data.length;
		size--;
		if(size==getCapacity()/4 && getCapacity()/2!=0) {
			resize(getCapacity()/2);
		}
		return e;
	}
	/**
	 * 檢視隊頭
	 */
	@Override
	public E getFront() {
		if(isEmpty()) {
			throw new IllegalArgumentException("空佇列，不可檢視隊頭");
		}
		return data[front];
	}
	/**
	 * 重寫Object的toString方法
	 */
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		sb.append(String.format("Queue:size=%d,capacity=%d\n", size,getCapacity()));
		sb.append("front [");
		for(int i=front;i!=tail;i=(i+1)%data.length) {
			sb.append(data[i]);
			if((i+1)%data.length!=tail) {
				sb.append(",");
			}
			
		}
		sb.append("] tail");
		return sb.toString();
	}
	
}

Test.java:

package Queue;

public class Test {

	public static void main(String[] args) {
		Queue<Integer> queue=new LoopQueue<Integer>();
		for(int i=0;i<10;i++) {
			queue.enqueue(i);
			System.out.println(queue);
			if(i%3==2) {//每插入3個，則取出隊頭元素。
				queue.dequeue();
				System.out.println(queue);
			}
		}
		
	}

}

控制檯輸出：