隊列學習

定義

隊列（queue）是隻允許在一端進行插入，在另一端進行刪除的運算受限的線性表。

1. 允許插入的一端叫做隊尾（rear）
2. 允許刪除的一端叫做隊頭（front）
3. 當隊列中沒有元素時叫做空隊列
4. 隊列是一種先進先出的線性表，也稱爲FIFO表

順序隊列

順序隊列的定義

隊列的順序存儲結構稱爲順序隊列，順序隊列實際上是運算受限的順序表

順序隊列的表示

1. 順序隊列用一個向量空間來存放當前的隊列中的元素
2. 由於隊列中隊頭和隊尾的位置是變化的，設置兩個指針front和rear分別指示隊頭元素和隊尾元素在向量空間中的位置，它們的位置在隊列初始化時均應置爲0

順序隊列的基本操作

1. 入隊時：將新元素插入rear所指的位置，並將rear+1
2. 出隊時：刪除front所指的元素，並將front+1

注意：

1. 當頭尾指針相等時，隊列爲空
2. 在非空隊列裏，隊頭指針始終指向隊頭元素，隊尾指針始終指向隊尾元素的下一個位置

順序隊列中的溢出現象

1. 下溢：隊列爲空時，做出隊操作產生的溢出現象
2. 真上溢：當隊列滿時，做入隊操作產生的空間溢出現象。
3. 假上溢：由於入隊和出隊操作中，隊頭指針只增加不減少，致使被刪除的元素空間永遠無法重新利用，從而導致入隊操作時產生假上溢現象。

循環隊列

爲了充分利用初始分配的向量空間，克服“假上溢”的方法是：將向量空間想像成一個首尾相接的圓環，並稱這種向量爲循環向量。存儲在其中的隊列稱爲循環隊列(circular queue).

循環隊列的基本操作

當循環隊列進行入隊和出隊操作時，隊頭和隊尾指針仍要+1。只不過當頭指針指向向量上界（queuesize - 1）時，其+1操作是指向向量空間的下界0.這種循環意義下的+1操作用代碼描述爲

1. if(front == queuesize - 1)
   {
       front = 0;
   }else
   {
       front ++;
   }

   if(front == queuesize - 1)
   {
   	front = 0;
   }else
   {
   	front ++;
   }

   
   

2. front = (front + 1) % queuesize;

   front = (front + 1) % queuesize;

   
   
   

循環隊列邊界處理的方法

1. 另設一個布爾變量來區分隊列的空和滿。
2. 設一個計數器記錄當前隊列中的元素

循環隊列的類型定義

#define queuesize 100001    //最大隊列長度
#define type int    //隊列中存儲的元素類型

struct queue
{
    int front;
    int rear;
    type data[queuesize];
    int count;  
//記錄隊列中的元素
};

#define queuesize 100001	//最大隊列長度
#define type int	//隊列中存儲的元素類型

struct queue
{
	int front;
	int rear;
	type data[queuesize];
	int count;	//記錄隊列中的元素
};

循環隊列的基本操作

/**
* Description:隊列初始化
*/
void InitQueue(struct queue *Q)
{
    Q -> front = Q -> rear = 0;
    Q -> count = 0;
}

/**
* Description:隊列判空
*/
int QueueEmpty(struct queue *Q)
{
    int flag;

    flag = (Q -> count == 0)? 1 : 0;

    return flag;
}

/**
* Description:隊列判滿
*/
int QueueFull(struct queue *Q)
{
    int flag;

    flag = (Q -> count == queuesize)? 1 : 0;

    return flag;
}

/**
* Description:入隊操作
*/
void EnQueue(struct queue *Q, type element)
{
    int flag;

    flag = QueueFull(Q);
    if(!flag)
    {
        Q -> data[Q -> rear] = element;
        Q -> count ++;
        Q -> rear = (Q -> rear + 1) % queuesize;
    }else
    {
        printf("failed\n");
    }
}

/**
* Description:出隊操作
*/
void Dequeue(struct queue *Q)
{
    int flag;
    type element;

    flag = QueueEmpty(Q);

    if(!flag)
    {
        element = Q -> data[Q -> front];
        Q -> front = (Q -> front + 1) % queuesize;
        Q -> count --;
    }else
    {
        printf("failed\n");
    }
}

/**
* Description:查找隊列中的指定元素
*/
void QueueSearch(struct queue *Q,
int k)
{
    if(!QueueEmpty(Q) && 1 <= k <= queuesize)
    {
        printf("%d\n",Q -> data[k - 1]);
    }else
    {
        printf("failed\n");
    }
}