數據結構之隊列

轉載：http://blog.chinaunix.net/uid-26548237-id-3473528.html

與棧相反，隊列是一種先進先出的線性表，它只允許在表的一端進行，而在另一端刪除元

素。

   在隊列中，允許插入的一端叫做隊尾，允許刪除的一端則稱爲隊頭。

1、鏈隊列——隊列的鏈式表示和實現

   用鏈表表示的隊列簡稱爲鏈隊列，一個鏈隊列顯然需要兩個分別指示對頭和隊尾的指針

（分別稱爲頭指針和尾指針）才能唯一確定。這裏，和線性表的單鏈表一樣，爲了操作方便起

見，我們也給隊列添加一個頭結點。

   鏈隊列的操作即爲單鏈表的插入和刪除操作的特殊情況，只是尚需修改尾指針或頭指針。

   單鏈隊列——隊列的鏈式存儲結構，如下所示。

//單鏈隊列，隊列的鏈式存儲結構
typedef struct QNode
{
    ElemType data;
    struct QNode *next;
}QNode,
*QueuePtr;

typedef struct
{
    QueuePtr front;            //隊頭指針
    QueuePtr rear;            //隊尾指針
}LinkQueue;

2、單鏈隊列的C語言操作

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

#define ElemType int

#define OK 1
#define ERROR 0


//單鏈隊列，隊列的鏈式存儲結構
typedef struct QNode
{
    ElemType data;
    struct QNode *next;
}QNode,
*QueuePtr;

typedef struct
{
    QueuePtr front;            //隊頭指針
    QueuePtr rear;            //隊尾指針
}LinkQueue;

//構造一個空隊列
int InitQueue(LinkQueue
*q)
{
    //
    q->front
= q->rear
= (QueuePtr)malloc(sizeof(QNode));
    if(q->front
== 
NULL)
    {
        fprintf(stderr,
"malloc() error.\n");
        return ERROR;
    }

    q->front->next
= NULL;
    q->rear->next
= NULL;

    return OK;
}

//銷燬隊列，Q不在存在
int DestroyQueue(LinkQueue
*q)
{
    //
    while(q->front)
    {
        q->rear
= q->front->next;
        free(q->front);
        q->front
= q->rear;
    }
    return OK;
}

//判斷隊列是否爲空
int IsEmptyQueue(LinkQueue
*q)
{
    return (q->front->next
== 
NULL && q->rear->next
== 
NULL);
}

//插入元素e爲新的隊尾元素
int InsertQueue(LinkQueue
*q, ElemType e)
{
    //
    QueuePtr p =
(QueuePtr)malloc(sizeof(QNode));
    if(p
== 
NULL)
    {
        fprintf(stderr,
"malloc() error.\n");
        return ERROR;
    }

    p->data
= e;
    p->next
= NULL;

    //如果隊列爲空
    if(IsEmptyQueue(q))
    {
        q->front->next
= p;
        q->rear
= p;
    }
    else
    {
        q->rear->next
= p;
        q->rear
= p;            //不要忘記這句啊
    }
    return OK;
}

//若隊列不空，則刪除隊頭元素，用e返回其值，並返回OK
int DeQueue(LinkQueue
*q, ElemType
*e)
{
    //
    if(IsEmptyQueue(q))
    {
        fprintf(stdout,
"the queue is null.\n");
        return ERROR;
    }

    //注意有隊頭結點
    QueuePtr temp;
    temp = q->front->next;
    *e 
= temp->data;

    q->front->next
= temp->next;

    //一個元素
    if(q->rear
== temp)
    {
        q->rear
= q->front;
    }

    free(temp);

    return OK;
}

//打印隊列
void printQueue(LinkQueue
*q)
{
    QueuePtr temp;
    temp = q->front->next;

    while(temp
!= 
NULL)
    {
        printf("%d ", temp->data);
        temp = temp->next;
    }

}

int main(int argc, char
**argv)
{
    LinkQueue *q;
    InitQueue(q);

    srand(time(NULL));

    int i 
= 0;
    for(i
= 0; i 
< 10; i++)
    {
        InsertQueue(q, i);
    }

    printf("插入隊列的元素爲:\n");
    printQueue(q);

    int e;
    DeQueue(q,
&e);
    printf("隊頭元素爲: %d\n", e);

    return 0;
}

3、循環隊列定義

   單鏈隊列時，當隊列爲空時，front等於rear，現在循環隊列當隊列滿時，也是front等

rear，那麼如何判斷此時的隊列究竟是空還是滿呢？

   辦法一是設置一個標誌變量flag，當front == rear，且flag = 0時爲隊列空，當front 

==rear，且flag = 1時爲隊列滿；

   辦法二是當隊列空時，條件就是front == rear，當隊列爲滿時，我們修改其條件，保留一

個元素空間。也就是說，隊列滿時，數組中還有一個空閒單元。例如下圖所示，我們就認爲此

隊列已經滿了，也就是說，我們不允許下圖中的右圖情況出現。

   我們重點來討論第二種方法，由於rear可能比front大，也可能比front小，所以，儘管它

們只相差一個位置時就說滿的情況，但也有可能是相差整整一圈。所以，若隊列的最大尺寸爲

QueueSize，那麼隊列滿的條件是(rear + 1) % QueueSize == front（取模"%"的目的就說爲

了整合rear與front大小爲一個問題)。比如上面這個例子，QueueSzie = 5，上圖中的左圖中

front = 0，而rear = 4，（4 + 1） % 5 = 0，所以，此時隊列滿。再看右圖，front = 2， 

而rear = 1，(1 + 1) %5 = 2，所以，此時隊列也是滿的。但是也有例外的情況。

   另外，通用的計算隊列長度的公式爲：(rear - front + QueueSize) % QueueSize

   循環隊列的順序存儲結構，如下所示。

#define ElemType int

typedef struct
{
    ElemType data[MAXSIZE];
    int front;
//頭指針
    int rear;
//尾指針，若隊列不爲空時，rear指向隊列尾元素的下一個位置
}SqQueue;

4、循環隊列的C操作

#define ElemType int

#define MAXSIZE 100

typedef struct
{
    ElemType data[MAXSIZE];
    int front;                //頭指針
    int rear;                //尾指針，若隊列不爲空時，rear指向隊列尾元素的下一個位置
}SqQueue;


#define OK     1
#define ERROR 0
//初始化一個空隊列
int InitQueue(SqQueue
*q)
{
    q->front
= 0;
    q->rear
= 0;

    return OK;
}

//循環隊列求隊列長度
//返回隊列的元素的個數，也就是隊列的當前長度
int QueueLength(SqQueue
*q)
{
    return (q->rear
- q->front
+ MAXSIZE) 
% MAXSIZE;
}

//循環隊列的入隊操作
//若隊列未滿，則插入元素e爲隊列新的隊尾元素
int EnQueue(SqQueue
*q, ElemType e)
{
    if((q->rear
+ 1) 
% MAXSIZE == q->front)    //隊列滿的判斷
    {
        return ERROR;
    }

    q->data[q->rear]
= e;                    //將元素e賦值給隊尾
    q->rear
= (q->rear
+ 1) MAXSIZE;        //rear指向後移一位置，若到最後則轉爲數組頭部
                                            //注意
    return OK;
}

//循環隊列的出對操作
//若隊列不空，則刪除q中隊頭元素，用e返回值
int DeQueue(SqQueue
*q, ElemType
*e)
{
    if(q->rear
== q->front)                //隊列空的判斷
    {
        return ERROR;
    }

    *e 
= q->data[q->front];                //將隊頭元素賦值給e
    q->front
= (q->front
+ 1) 
% MAXSIZE;//front指針向後一位置，若到最後，則轉到數組頭部

    return OK;
}

          參數：嚴蔚敏老師之《數據結構》、《大話數據結構》