定義：一種可以實現“先進先出”的存儲結構

分類

　　　　鏈式隊列 -- 用鏈表實現

　　　　靜態隊列 -- 用數組實現

　　　　　　　　　　　　靜態隊列通常都必須是循環隊列

　　　　　　　　　　　　循環隊列的講解：

　　　　　　　　　　　　　　　　1.靜態隊列為什麽必須是循環隊列

　　　　　　　　　　　　　　　　2.循環隊列需要幾個參數來確定

　　　　　　　　　　　　　　 　　　　需要兩個參數來進行確定：front rear

　　　　　　　　　　　　　　　　3.循環隊列各個參數的含義

　　　　　　　　　　　　　　　　　　2個參數在不同的場合有不同的含義

　　　　　　　　　　　　　　　　　　　　　　建議初學者先記住，後面再想

　　　　　　　　　　　　　　　　　　　　　　　　　　1）、隊列初始化

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　front 和 rear 的值都是零

　　　　　　　　　　　　　　　　　　　　　　　　　　2）、隊列非空

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　front 代表的是隊列的第一個元素

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　rear 代表的是隊列的最後一個有效元素的下一個元素

　　　　　　　　　　　　　　　　　　　　　　　　　　3）、隊列空

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　front 和 rear 值相等，但不一定為零

　　　　　　　　　　　　　　　　4.循環隊列入隊偽算法講解

　　　　　　　　　　　　　　　　　　　　1.將值存入r所代表的位置

　　　　　　　　　　　　　　　　　　　　2.最容易犯得錯誤的寫法：rear = rear + 1；

　　　　　　　　　　　　　　　　　　　　　正確的寫法:rear = (rear+1)%(數組的長度);

　　　　　　　　　　　　　　　　5.循環隊列出隊偽算法講解

　　　　　　　　　　　　　　　　　　　　1.出隊和入隊是一致的，front=(front+1)%(數組的長度);

　　　　　　　　　　　　　　　　6.如何判斷循環隊列為什麽為空

　　　　　　　　　　　　　　　　　　　　1.如果兩個參數的值相等，那麽該隊列就一定為空

　　　　　　　　　　　　　　　　7.如何判斷循環隊列是否已滿

　　　　　　　　　　　　　　　　　　　　兩種方式：

　　　　　　　　　　　　　　　　　　　　　　1、多增加一個標識位

　　　　　　　　　　　　　　　　　　　　　　2、少用一個元素(也就是判斷兩者是不是緊挨著)

　　　　　　　　　　　　　　　　　　　　　　　　if((r+1)%(數組的長度)==f){

　　　　　　　　　　　　　　　　　　　　　　　　　　已滿

　　　　　　　　　　　　　　　　　　　　　　　　}else{

　　　　　　　　　　　　　　　　　　　　　　　　　　不滿

　　　　　　　　　　　　　　　　　　　　　　　　}

代碼實現：

#include <stdio.h>
#include <malloc.h>



typedef struct QUEUE {
    int *pBase;
    int front;
    int rear;
} QUEUE;

void init(QUEUE* pQ);
bool en_Queue(QUEUE* pQ,int val);
bool full_QUEUE(QUEUE* pQ);
bool traverse_Queue(QUEUE* pQ);
bool empty_Queue(QUEUE* pQ);
bool out_Queue(QUEUE * pQ,int *val);



int main(void) {
    QUEUE pQ;
    int val;
    init(&pQ);
    en_Queue(&pQ,1);
    en_Queue(&pQ,2);
    en_Queue(&pQ,3);
    en_Queue(&pQ,4);
    en_Queue(&pQ,5);
    en_Queue(&pQ,6);
    en_Queue(&pQ,7);
    en_Queue(&pQ,8);

    if(traverse_Queue(&pQ)) {
        printf("為空!\n");
    }
    if(out_Queue(&pQ,&val)) {
        printf("出隊成功!出隊的值為%d!\n",val);
    } else {
        printf("為空!\n");
    }
    if(traverse_Queue(&pQ)) {
        printf("為空!\n");
    }
    return 0;
}

void init(QUEUE* pQ) {
    pQ->pBase = (int *)malloc(sizeof(int) * 6);
    pQ->front = 0;
    pQ->rear = 0;
}

bool en_Queue(QUEUE* pQ,int val) {
    if ( full_QUEUE(pQ) ) {
        return false;
    } else {
        pQ->pBase[pQ->rear] = val;
        pQ->rear = (pQ->rear+1) % 6;

        return true;
    }
}

bool full_QUEUE(QUEUE* pQ) {
    if ( (pQ->rear + 1) % 6 == pQ->front  )
        return true;
    else
        return false;
}

bool traverse_Queue(QUEUE* pQ) {
    if(empty_Queue(pQ)) {
        return true;
    } else {
        int i = pQ->front;
        while(i != pQ->rear) {
            printf("%d   ",pQ->pBase[i]);
            i = (i+1)%6;
        }
        printf("\n");
        return false;
    }
}

bool empty_Queue(QUEUE* pQ) {
    if(pQ->front == pQ->rear) {
        return true;
    } else {
        return false;
    }
}

bool out_Queue(QUEUE * pQ,int *val) {
    if(empty_Queue(pQ)) {
        printf("棧表為空!\n");
        return false;
    } else {
        *val = pQ->pBase[pQ->front];
        pQ->front = (pQ->front+1)%6;
        return true;
    }
}

線性結構的常見應用之一 隊列