java實現隊列

隊列的定義

　　隊列的特點是節點的排隊次序和出隊次序按入隊時間先后確定，即先入隊者先出隊，后入隊者后出隊。即我們常說的FIFO(first in first out)先進先出。　　　　

順序隊列定義及相關操作

　　順序存儲結構存儲的隊列稱為順序隊列，內部使用一個一維數組存儲，用一個隊頭指針front指向隊列頭部節點（即使用int類型front來表示隊頭元素的下標），用一個隊尾指針rear，指向隊列尾部元素(int類型rear來表示隊尾節點的下標)。

　　初始化隊列時: front = rear = -1 (非必須，也可設置初始值為0，在實現方法時具體修改)

　　隊列滿時：     rear = maxSize-1 (其中maxSize為初始化隊列時，設置的隊列最大元素個數)

　　隊列為空時：  front = rear

　　下面使用java實現一個基於一維數組的順序隊列，代碼如下：

/**
 * 定義一個queue
 */
class ArrayQueue{
    private int[] data ; //隊列中存放的數據
    private int maxSize ; //隊列的大小
    private int front ;//指向隊列頭部的指針
    private int rear ; //指向隊列尾部的指針

    public ArrayQueue(int maxSize){
        this.maxSize = maxSize;
        data = new int[maxSize];
        front = -1;
        rear = -1;
    }

    /**
     * 判斷隊列是否已滿
     * @return
     */
    public boolean isFull(){
        return rear == maxSize -1 ;
    }

    /**
     * 判斷隊列是否為空
     * @return
     */
    public boolean isEmpty(){
        return rear == front;
    }

    /**
     * 添加數據到隊列
     * @param n
     */
    public void add(int n){
        if(isFull()){
            System.out.println("隊列已滿，不能添加");
            return;
        }
        data[++rear] = n;
    }

    /**
     * 顯示頭部數據
     * @return
     */
    public void head(){
        if(isEmpty()){          
   　　　　　　throw new RuntimeException("隊列為空");
        }
        System.out.println(data[front+1]);
    }

    /**
     * 取出頭部數據
     * @return
     */
    public int pop(){
        if(isEmpty()){
            throw new RuntimeException("隊列為空");
        }
        int a = data[++front];
        data[front] = 0;
        return a;
    }

    /**
     * 打印全部數據
     */
    public void print(){
        if(isEmpty()){
            System.out.println("隊列為空");
            return;
        }
        for(int i=0;i<data.length;i++){
            System.out.printf("array["+i+"]=%d\n",data[i]);
        }
    }
}

　　簡單描述順序隊列的入隊(add方法)：

　　

public static void main(String []args) {
        //1.聲明一個可以存儲6個元素的順序隊列，默認值為0,front 和rear指針為-1
        ArrayQueue queue = new ArrayQueue(6);
        //2.向順序隊列中添加元素
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        queue.add(5);
        queue.add(6);
        //2.1打印當前隊列元素
        queue.print();
        //3.將順序隊列中元素取出
        queue.pop();
        queue.pop();
        queue.pop();
        queue.pop();
        queue.pop();
        queue.pop();
        //4.隊列中元素全部取出
}

　　在代碼中初始化了一個大小為6的順序隊列，下圖展示了第一步(即代碼ArrayQueue queue = new ArrayQueue(6))中隊列元素及指針情況

 

　　其中front和rear指向的虛線框實際並不存在，僅用來表示初始化時的默認狀態，因我們實現的隊列元素使用int[]存儲元素，所以初始值均為0(如用Object[]或范型則初始值為null)

      執行queue.add(1)方法后隊列的狀態如下圖：

 

　　可以看到向隊列中添加元素后，rear指針向后移動一個位置指向第一個元素位置，后面繼續添加后面5個元素后隊列如下圖所示

　　接下來看下隊列的出隊情況 

　　當第一次執行queue.pop()方法后，隊列元素如上圖所示，此時隊列剩下5個元素

　　當第六次執行queue.pop()方法后，隊列元素如下圖所示

　　此時隊列中元素已全部出隊，按正常邏輯應該可以添加元素到隊列中，但此時添加元素卻會報隊列已滿錯誤（rear=maxSize-1)，當然即使前面元素未出隊也會報相同錯誤。這就是我們常說的“假溢出”問題。為解決這個問題，就引出了我們的環形隊列。

環形隊列

　　環形隊列，顧名思義即讓普通隊列首尾相連，形成一個環形。當rear指向尾元素后，當隊列有元素出隊時，可以繼續向隊列中添加元素。

　　這里我使用的是rear指針指向最后一個節點的后一個元素，即會占用一個位置用來表示隊列已滿。

　　

　　初始化隊列時: front = rear = 0

　　隊列滿時：    ( rear +1 ) % maxSize == front (其中maxSize為初始化隊列時，設置的隊列最大元素個數)

　　這里不能使用rear = maxSize-1作為判斷隊滿的條件，因使用環形隊列方式實現，當第一次隊滿時，rear = maxSize -1，執行出隊操作后原隊頭位置空出，此時繼續執行入隊操作，則rear向后移動一個位置，則rear = 0，而此時隊列也是已滿狀態。所以只要rear 向前移動一個位置就等於front時，就是隊滿的情況。

　　隊列為空時：  front == rear

　　先看下具體代碼

　　

public class CycleQueue {

    /**
     *
     */
    private int maxSize ;
    private int data[] ;
    private int front ;
    /**
     * 這里rear指向最后一個數據的后面一個位置，即隊列中有一個為空占位
     */
    private int rear ;

    public CycleQueue(int maxSize){
        this.maxSize = maxSize;
        data = new int[maxSize];
        front = 0;
        rear = 0;
    }

    /**
     * 判斷隊列是否已滿
     * 因是循環隊列，所以rear值可能小於front，所以不能使用rear == maxSize -1來判斷
     * @return
     */
    public boolean isFull(){
        return (rear + 1) % maxSize == front;
    }

    public boolean isEmpty(){
        return rear == front;
    }

    public void add(int n){
        if(isFull()){
            System.out.println("隊列已滿，不能添加");
            return;
        }
        data[rear] = n;
        rear = (rear + 1) % maxSize;
    }

    public void head(){
        if(isEmpty()){
            throw new RuntimeException("隊列為空");
        }
        System.out.println("head="+data[front]);
    }

    public int pop(){
        if(isEmpty()){
            throw new RuntimeException("隊列為空");
        }
        int value = data[front];
        front = (front + 1) % maxSize;
        return value;
    }

    public void print(){
        if(isEmpty()){
            System.out.println("隊列為空");
            return;
        }
        for(int i= front; i<front+size(); i++){
            System.out.printf("array"+(i%maxSize)+"=%d",data[i%maxSize]);
        }
    }

    /**
     * 因是循環隊列，所以會出現rear<front情況，這里需要+maxSize
     * @return
     */
    public int size(){
        return (rear - front + maxSize)%maxSize;
    }
}

　　下面再以圖解的方式講解一下環形隊列的入隊出隊以及隊滿情況。當執行初始化代碼后

CycleQueue queue = new CycleQueue(6);　　 

　　此時front = rear = 0，隊列為空。當第一次執行queue.add(1)后，環形隊列元素如下圖所示

 

　　當依次執行queue.add(2);queue.add(3);queue.add(4);queue.add(5);后，達到(rear+1)%maxSize=front （即rear=5）條件，隊列已滿不能添加新元素。此時環形隊列元素情況如下圖

 

　　所以這種情況會浪費一個空間來作為判滿的條件。

　　下面執行出隊操作，當第一次執行出隊操作queue.pop()方法后，環形隊列元素情況如下圖所示

　　　此時 (rear+1)%maxSize = 0  不等於 front=1 ,所以可以繼續向隊列中添加元素，也就不會出現假溢出的情況。當執行入隊(例queue.add(6))操作后，rear = (rear+1)%maxSize 即rear=0，以此來生成環形隊列。此時隊列元素情況如下圖所示

　　另外，再說明下環形隊列有效元素個數問題，如果不是環形隊列，則有效元素個數size = rear - front。而使用環形實現后，會出現rear<front的情況，所以這里使用(rear-front+maxSize)%maxSize的方式計算有效元素個數。（或者在內部定義一個size屬性，當元素入隊時size++，當出隊時size--）

　　因此在打印隊列中元素時，從front位置開始至 front+size位置結束來循環打印有效元素。

總結

　　如果不實用環形隊列方式實現隊列，則會出現“假溢出”情況（即隊列滿后，將全部元素出隊卻不能繼續添加元素的情況）。而環形隊列會在隊頭元素出隊后，將隊尾指針rear重新分配為0，以達到循環使用隊列空間的目的。