佇列是一種先進先出的資料結構，它和棧的性質正好相反，但是兩者卻經常結合在一起實現一些特殊的操作。

1.佇列的介面

public interface QueueADT {
	//入隊
	public void enqueue(Object element);
	//出隊
	public Object dequeue();
	//返回隊首元素
	public Object first();
	//是否為空
	public boolean isEmpty();
	//返回佇列大小
	public int size();
	
	public String toString();
}

public class LinkedQueue implements QueueADT {
	
	// 連結串列節點類，內部類實現，包含資料域和指標域
	class Node {
		int data; // 資料域
		Node next;// 指標域

		public Node(int data) {
			this.data = data;
		}
	} 
	//指向隊首、隊尾節點
	private Node front,rear;
	//維護佇列的大小
	private int count;
	
	public LinkedQueue() {
		front=null;
		rear=null;
		count=0;
	}
	//保證出棧或者出佇列的是頭結點，這樣才能完成更新，所以對於棧的入棧操作，是從尾節點開始構造的
	//佇列的入隊操作，是從頭結點開始構造的
	@Override
	public void enqueue(Object element) {
		Node node=new Node((Integer)element);
		if(isEmpty()){
			front=rear=node;
		}else{
			rear.next=node;
			rear=node;
		}
		count++;
	}
	
	@Override
	public Object dequeue() {
		if(isEmpty()){
            System.out.println("佇列中沒有元素");
            System.exit(1);
        }
		Object result=front.data;
		front=front.next;
		count--;
		return result;
	}

	@Override
	public Object first() {
		return front.data;
	}

	@Override
	public boolean isEmpty() {
		return (size()==0);
	}

	@Override
	public int size() {
		return count;
	}
	
	public static void main(String[] args) {
        
        LinkedQueue queue = new LinkedQueue();
        
        System.out.println("依次將0到9入隊，然後連續出隊5次");
        for(int i = 0;i < 10;i++)
            queue.enqueue(i);
        for(int i = 0;i < 5;i++)
            queue.dequeue();
        System.out.println("佇列的大小為： " + queue.size());
        System.out.println("佇列為空嗎？： " + queue.isEmpty());
        System.out.println("佇列的頭為： " + queue.first());

    }

}
 

//用陣列實現佇列，如果隊首不固定，隨著出隊操作，陣列前面的空間就被浪費，但是如果隊首固定，每次出隊都要移動所有元素
public class ArrayQueue implements QueueADT {
	
	private Object[] contents;
	//由於陣列實現，rear是一個整數指標，指向陣列的索引即可
	private int rear;
	private static int SIZE = 10;
	
	public ArrayQueue(){
        contents = new Object[SIZE];
        rear = 0;
    }
	
	public void expand(){
        Object[] larger = new Object[size()*2];
        for(int index = 0;index < rear;index++)
            larger[index] = contents[index];
        
        contents = larger;
    }
	
	@Override
	public void enqueue(Object element) {
		if(rear == contents.length)
            expand();
        contents[rear] = element;
        rear++;
	}

	@Override
	public Object dequeue() {
		if(isEmpty()){
            System.out.println("佇列為空");
            System.exit(1);
        }
        Object result = contents[0];
        //為了保證隊首固定，每次出隊之後都要移動元素
        for(int index = 0;index < rear;index++)
                contents[index] = contents[index+1];
        rear--;
        return result;        
	}

	@Override
	public Object first() {
		return contents[0];
	}

	@Override
	public boolean isEmpty() {
		return (size()==0);
	}

	@Override
	public int size() {
		return rear;
	}

}
 

//使用迴圈佇列可以消除元素頻繁移動帶來的效率問題，用兩個指標分別指向隊首和隊尾，走到陣列末尾時，在陣列頭部繼續入隊
public class CircularArrayQueue implements QueueADT{
	
	private Object[] contents;
    private int front,rear;//front為隊頭下標，rear為隊尾的下一個元素的下標
    private int count;//標記佇列元素個數
    private static int SIZE = 10;
    
    
    public CircularArrayQueue(){
        contents = new Object[SIZE];
        front = -1;
        rear = 0;
        count = 0;
    }
	//對棧還有佇列進行操作，或者其他類，一般都要特殊考慮一下狀態為空或者初始化時的特殊值    
	@Override
	public void enqueue(Object element) {
		if(isEmpty()){
			contents[0]=element;
			front=0;
			rear=1;
			count++;
		}else{
			contents[rear]=element;
			rear=(rear+1)%contents.length;
			count++;
		}
	}

	@Override
	public Object dequeue() {
		if(isEmpty()){
            System.out.println("佇列為空！！！");
            System.exit(1);
        }
		Object result = contents[front];
        front = (front + 1) % contents.length;
        count--;
        return result;    
	}

	@Override
	public Object first() {
		return contents[front];
	}

	@Override
	public boolean isEmpty() {
		return (size()==0);
	}

	@Override
	public int size() {
		return count;
	}

}