數據結構：線性結構之隊列

世上有兩種最耀眼的光芒，一種是太陽，一種是我們努力的模樣。

什麼是隊列？

在日常生活中隊列很常見，像我們經常排隊購物或購票，排隊是體現了“先來先服務”的原則。 隊列在計算機系統中的應用也非常廣 泛。例如: 操作系統中的作業排隊。在多道程序運行的計算機系統中，可以同時有多個作業運行，它們的運算結果都需要通過通道輸出，若通道尚未完成輸出，則後來的作業應排隊等待，每當通道完成輸出時，則從隊列的隊頭退出作業進行輸出操作，而凡是申請該通道輸出的作業都從隊尾進人該隊列等待。

隊列(Queue)是另一種限定性線性表，它只允許插人在表的一端進行， 而刪除在表的另一端進行，我們將這種數據結構稱爲隊或隊列，把允許插人的一端叫隊尾( rear)，把允許刪除的一端叫隊頭 ( front)。隊列的插人操作通常稱爲人隊列或進隊列，而隊列的刪除操作則稱爲出隊列或退隊列。當隊列中無數據元素時，稱爲空隊列。根據隊列的定義可知，隊頭元素總是最先進隊列的，也總是最先出隊列;隊尾元素總是最後進隊列，因而也是最後出隊列。這種表是按照先進先出(FIFO，first in first out )的原則組織數據的，因此，隊列也被稱爲“先進先出”表。這與
我們日常生活中的排隊是一致的。

隊列的存儲結構

與線性表、棧類似，隊列也有順序存儲和鏈式存儲兩種存儲方法。

（一）順序隊列

隊列的順序存儲結構可以簡稱爲順序隊列，也就是利用-組地址連續的存儲單元依次存 放隊列中的數據元素。一般情況下,我們使用一維數組來作爲隊列的順序存儲空間，另外再設立兩個指示器：一個爲指向隊頭元素位置的指示器front,另個爲指向隊尾的元素位置的指示器rear。

C語言實現順序隊列

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 5
#define dataType int

typedef struct{
    dataType data[MAXSIZE];
    int rear;
    int front;
}CSeQueue;

//置空
CSeQueue* Init_CSeQueue(){

    CSeQueue *queue = (CSeQueue *) malloc(sizeof(CSeQueue));
    if (queue == NULL) {
        return 0;
    }
    queue->rear = 0;
    queue->front = 0;
    return queue;
}

//非空判斷
int IsEmpty_CSeQueue(CSeQueue *queue) {

    if (queue->front == queue->rear) {
        return 1;
    } else {
        return 0;
    }
}

//判滿
int IsFull_CSeQueue(CSeQueue *queue){

    if (queue->rear == MAXSIZE) {
        return 1;
    }
    return 0;
}

//入隊
int In_CSeQueue(CSeQueue *queue, dataType data) {

    if (IsFull_CSeQueue(queue)) {
        return 0;
    }

    queue->data[queue->rear] = data;
    queue->rear++;
    return 1;
}

//出隊
int Out_CSeQueue(CSeQueue *queue, dataType *data) {

    if (IsEmpty_CSeQueue(queue)) {
        return 0;
    }

    *data = queue->data[queue->front];
    queue->front++;
    return 1;
}

存在的問題：

建立的空隊及入隊、出隊的示意圖如上，設MAXSIZE=5。從圖中可以看到，隨着
入隊、出隊的進行，會使整個隊列整體向後移動，就會出現隊尾指針一靜一動到了最後，再有元素入隊就會出現“假溢出”，而事實上此時隊中並未真的"滿員"，這是由於“隊尾入、隊頭出”這種受限制的操作所造成的。

循環隊列

解決假溢出的方法之一是將 隊列的數據區data[0…MAXSIZE-1]看成頭、尾相接的循環結構，即規定最後一個單元的後繼爲第一個單元， 這樣整個數據區就像 一個環，我們形象地稱之爲循環隊列。頭、尾指針的關係不變，即頭指示器front總是指向隊列中實際隊頭元素的前面一個位置，而尾指示器rear總是指向隊尾元素。

C語言實現循環隊列

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 6
#define dataType int

typedef struct{
    dataType data[MAXSIZE];
    int rear;
    int front;
}CSeQueue;

//置空
CSeQueue* Init_CSeQueue(){

    CSeQueue *queue = (CSeQueue *) malloc(sizeof(CSeQueue));
    if (queue == NULL) {
        return 0;
    }
    queue->rear = 0;
    queue->front = 0;
    return queue;
}

//非空判斷
int IsEmpty_CSeQueue(CSeQueue *queue) {

    if (queue->front == queue->rear) {
        return 1;
    } else {
        return 0;
    }
}

//判滿
int IsFull_CSeQueue(CSeQueue *queue){

    if ((queue->rear + 1)%MAXSIZE == queue->front) { //浪費一個空間，用於區分隊空和隊滿
        return 1;
    } else {
        return 0;
    }
}

//入隊
int In_CSeQueue(CSeQueue *queue, dataType data) {

    if (IsFull_CSeQueue(queue)) {
        return 0;
    }

    queue->data[queue->rear] = data;
    queue->rear = (queue->rear + 1) % MAXSIZE;
    return 1;
}

//出隊
int Out_CSeQueue(CSeQueue *queue, dataType *data) {

    if (IsEmpty_CSeQueue(queue)) {
        return 0;
    }

    *data = queue->data[queue->front];
    queue->front = (queue->front + 1 ) % MAXSIZE;
    return 1;
}

Java實現循環隊列

package cn.boom.queue;

import java.util.Arrays;

public class SeqQueue<T> implements Queue<T> {

    private T data[];
    private int front;
    private int rear;
    private int size;

    public SeqQueue() {

        this.data = (T[]) new Object[11];
        this.front = 0;
        this.rear = 0;
        this.size = 0;
    }

    public SeqQueue(int capacity) {

        this.data = (T[]) new Object[capacity + 1];
        this.front = 0;
        this.rear = 0;
        this.size = 0;
    }

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

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

    @Override
    public void enQueue(T e) {

        if ((rear + 1) % getCapacity() == front) { //隊滿
            updateCapacity(data.length * 2);
        }

        data[rear] = e;
        this.rear = (this.rear + 1) % getCapacity();
        size++;
    }

    @Override
    public T deQueue() {

        if (isEmpty()) {
            throw new IllegalArgumentException("The Queue is null !");
        }

        T elem = data[front];
        this.front = (this.front + 1) % getCapacity();
        size--;

        if (size < getCapacity() / 2) {
            updateCapacity(getCapacity() / 2);
        }

        return elem;
    }

    @Override
    public T getFront() {

        if (isEmpty()) {
            throw new IllegalArgumentException("The Queue is null !");
        }
        return data[front];
    }

    /**
     * 動態擴容縮容
     * @param newCapacity
     */
    private void updateCapacity(int newCapacity) {

        T[] newData = (T[]) new Object[newCapacity];

        for (int i = 0; i < this.size; i++) {

            newData[i] = this.data[(i + front) % getCapacity()];
        }

        this.data = newData;
        this.front = 0; //
        this.rear = size;
    }

    /**
     * 獲取容量
     * @return
     */
    private int getCapacity(){
        return data.length;
    }

    @Override
    public String toString() {

        StringBuilder res = new StringBuilder();
        res.append("SeqQueue{ data = [");

        for (int i = front; i != rear; i = (i + 1) % getCapacity()) {

            if ((i + 1) % getCapacity() != rear) {
                res.append(data[i] + ", ");
            } else {
                res.append(data[i]);
            }

        }
        res.append("]");
        res.append(", front" + front);
        res.append(", rear=" + rear);
        res.append(", size=" + size);
        res.append(", capacity=" + (getCapacity() - 1));
        res.append("}");
        return res.toString();
    }
}

（二）鏈隊列

循環隊列雖然解決了"假溢出"問題，但若用戶無法預計所需隊列的最大空間，我們就只能採用鏈式結構來存儲隊列。鏈式存儲的隊列稱爲鏈隊列。
和鏈棧類似，可以用單鏈表來實現鏈隊列，根據隊列的FIFO原則，鏈隊列中爲了操作方便，可以採用帶頭結點的單鏈表表示隊列，並設置一個隊頭指針(front)和一個爲指針(rear)。

C語言實現鏈隊列

#include <stdio.h>
#include <stdlib.h>

#define dataType int

typedef struct QueueNode {
    dataType data;
    struct QueueNode *next;
} Node;

typedef struct {
    Node *front;
    Node *rear;
} slQueue;

//置空
slQueue *Init_slQueue() {
    slQueue *queue = (slQueue *) malloc(sizeof(slQueue));
    queue->front = (Node *) malloc(sizeof(Node));//初始化頭節點
    queue->rear = queue->front;
    return queue;
}

//判空
int IsEmpty_slQueue(slQueue *queue) {

    if (queue->front == queue->rear) {
        return 1;
    }
    return 0;
}


//入隊 : rear隊尾入隊
int In_slQueue(slQueue *queue, dataType data) {

    Node *node = (Node *) malloc(sizeof(Node));
    if (node == NULL) {
        return 0;
    }
    node->data = data;
    node->next = NULL;
    queue->rear->next = node;
    queue->rear = node;
    return 1;
}

//出隊 頭結點後做隊首
int Out_slQueue(slQueue *queue, dataType *data) {

    if (IsEmpty_slQueue(queue)) {
        return 0;
    }

    *data = queue->front->next->data;

    if (queue->front->next == queue->rear) {
        queue->rear = queue->front;
        queue->front->next = queue->front->next->next;
    } else {
        queue->front->next = queue->front->next->next;
    }
    return 1;
}

Java實現鏈隊列

複用線性表中的單鏈表LinkedList，很方便的實現了鏈隊列。
數據結構：線性數據結構

package cn.boom.queue;

public class LinkedListQueue<T> implements Queue<T> {

    private LinkedList<T> linkedList;

    public LinkedListQueue(){
        linkedList = new LinkedList<T>();
    }

    @Override
    public int getSize() {
        return linkedList.getSize();
    }

    @Override
    public boolean isEmpty() {
        return linkedList.isEmpty();
    }

    @Override
    public void enQueue(T e) {
        linkedList.addLast(e);
    }

    @Override
    public T deQueue() {
        return linkedList.remove(0);
    }

    @Override
    public T getFront() {
        return linkedList.get(0);
    }

    @Override
    public String toString() {
        return "LinkedListQueue{" +
                "linkedList=" + linkedList +
                '}';
    }
}

參考文獻

[1]王曙燕.數據結構與算法:人民郵電出版社