編程的隊列有什麼用

A. Python Queue 入門

Queue 叫隊列，是數據結構中的一種，基本上所有成熟的編程語言都內置了對 Queue 的支持。

Python 中的 Queue 模塊實現了多生產者和多消費者模型，當需要在多線程編程中非常實用。而且該模塊中的 Queue 類實現了鎖原語，不需要再考慮多線程安全問題。

該模塊內置了三種類型的 Queue，分別是 class queue.Queue(maxsize=0) ， class queue.LifoQueue(maxsize=0) 和 class queue.PriorityQueue(maxsize=0) 。它們三個的區別僅僅是取出時的順序不一致而已。

Queue 是一個 FIFO 隊列，任務按照添加的順序被取出。

LifoQueue 是一個 LIFO 隊列，類雀指似堆棧，後添加的任務先被取出。

PriorityQueue 是一個優先順序隊列，隊列裡面的肆歲友任務按照優先順序排序，優先順序高的先被取出。

如你所見，就是上面所說的三種不同類型的內置隊列，其中 maxsize 是個整數，用於設置可以放入隊列中的任務數的上限。當達到這個大小的時候，插入操作將阻塞至隊列中的任務被消費掉。如果 maxsize 小於等於零，則隊列尺寸為無限大。

向隊列中添加任務，直接調用 put() 函數即可

put() 函數完整的函數簽名如下 Queue.put(item, block=True, timeout=None) ，如你所見，該函數有兩個可選參數。

默認情況下，在隊列滿時，該函數會一直阻塞，直到隊列中有空餘的位置可以添加任務為止。如果 timeout 是正數，則最多阻塞 timeout 秒，如果這段時間內還沒有空餘的位置出來，則會引發 Full 異常。

當 block 為 false 時，timeout 參數將失效。同時如果隊列中沒有空餘的位置可添加任務則會引發 Full 異常，否則會直接把任務放入隊列並返回，不會阻塞。

另外，還可以通過 Queue.put_nowait(item) 來添加任務，相當於 Queue.put(item, False) ，不再贅述。同樣，在隊列滿時，該操作會引發 Full 異常。

從隊列中獲取任務，直接調用 get() 函數即可。

與 put() 函數一樣， get() 函數也有兩個可選參數，完整簽名如下 Queue.get(block=True, timeout=None) 。

默認情況下，當隊列空時調用該函數會一直阻塞，直到隊列中有任務可獲取為止。如果 timeout 是正數，則最多阻塞 timeout 秒，如果這段時間內還沒有任務可獲取，則會引發 Empty 異常。

當 block 為 false 時，timeout 參數將失效。同時如果隊列中沒有任務可獲取則會立刻引發 Empty 異常，否則會直接獲取一個任務並返回，不會阻塞。

另外，還可以通過 Queue.get_nowait() 來獲取任務，相當於 Queue.get(False) ，不再贅述。同裂槐樣，在隊列為空時，該操作會引發 Empty 異常。

Queue.qsize() 函數返回隊列的大小。注意這個大小不是精確的，qsize() > 0 不保證後續的 get() 不被阻塞，同樣 qsize() < maxsize 也不保證 put() 不被阻塞。

如果隊列為空，返回 True ，否則返回 False 。如果 empty() 返回 True ，不保證後續調用的 put() 不被阻塞。類似的，如果 empty() 返回 False ，也不保證後續調用的 get() 不被阻塞。

如果隊列是滿的返回 True ，否則返回 False 。如果 full() 返回 True 不保證後續調用的 get() 不被阻塞。類似的，如果 full() 返回 False 也不保證後續調用的 put() 不被阻塞。

queue.Queue() 是 FIFO 隊列，出隊順序跟入隊順序是一致的。

queue.LifoQueue() 是 LIFO 隊列，出隊順序跟入隊順序是完全相反的，類似於棧。

優先順序隊列中的任務順序跟放入時的順序是無關的，而是按照任務的大小來排序，最小值先被取出。那任務比較大小的規則是怎麼樣的呢。

注意，因為列表的比較對規則是按照下標順序來比較的，所以在沒有比較出大小之前 ，隊列中所有列表對應下標位置的元素類型要一致。

好比 [2,1] 和 ["1","b"] 因為第一個位置的元素類型不一樣，所以是沒有辦法比較大小的，所以也就放入不了優先順序隊列。

然而對於 [2,1] 和 [1,"b"] 來說即使第二個元素的類型不一致也是可以放入優先順序隊列的，因為只需要比較第一個位置元素的大小就可以比較出結果了，就不需要比較第二個位置元素的大小了。

但是對於 [2,1] 和 1 [2,"b"] 來說，則同樣不可以放入優先順序隊列，因為需要比較第二個位置的元素才可以比較出結果，然而第二個位置的元素類型是不一致的，無法比較大小。

綜上，也就是說， 直到在比較出結果之前，對應下標位置的元素類型都是需要一致的 。

下面我們自定義一個動物類型，希望按照年齡大小來做優先順序排序。年齡越小優先順序越高。

本章節介紹了隊列以及其常用操作。因為隊列默認實現了鎖原語，因此在多線程編程中就不需要再考慮多線程安全問題了，對於程序員來說相當友好了。

B. 棧和隊列的作用是什麼它們主要可以應用在哪些方面

棧和隊列都屬於一位鏈表，棧是後進先出，進和出都是在同一端進行，就好像一筒羽毛球，只有把上面拿出來，下面的才能拿隱返出來；隊列是先進先出的，進和出分別在不同的端進行，比如排隊的人，排在前面的人先到櫃台辦理業務，後面來的人後得到服務。

棧作為一種數據結構，是一種只能在一汪核端進行插入和刪除操作的特殊線性表。它按照先進後出的原則存儲數據，先進入的數據被壓入棧底。

最後的數據在棧頂，需要讀數據的時候從棧頂開始彈出數據（最後一個數據被第一個讀出來）。棧具有記憶作用，對棧的插入與刪除操作中，不需要改變棧底指困攜掘針。

(2)編程的隊列有什麼用擴展閱讀：

在計算機系統中，棧則是一個具有以上屬性的動態內存區域。程序可以將數據壓入棧中，也可以將數據從棧頂彈出。在i386機器中，棧頂由稱為esp的寄存器進行定位。壓棧的操作使得棧頂的地址減小，彈出的操作使得棧頂的地址增大。

棧在程序的運行中有著舉足輕重的作用。最重要的是棧保存了一個函數調用時所需要的維護信息，這常常稱之為堆棧幀或者活動記錄。

C. 棧和隊列在計算機系統中有哪些應用

棧是在一列數據中，一塊後進先出的地方，在編程中比如1+2+3+……+100，就可以利用棧來完成；而隊列先進先出的地方，比如列印文檔就是排隊等候，先到的就先得列印一樣。在計算機系統中編程方面用得最多也最明顯，在已經成為程序成品的不太明顯，最明顯的就是列印。祥鋒

棧和隊列都屬於一位鏈表，棧是後進先出，進和出都是謹仔晌在同一端進行，就好像一筒羽毛球，只有把上面拿出來，下面的才能拿出來；隊列是先進先出的，進和出分別在不同的端進行，比如排隊的人，排在前面的人先到櫃台辦理業務，後面來的人後得到服務。

(3)編程的隊列有什麼用擴展閱讀：

系統或者數據結構棧中數據內容的讀取與戚核插入（壓入push和彈出pop）是兩回事！壓入是增加數據，彈出是刪除數據 ，這些操作只能從棧頂即最低地址作為約束的介面界面入手操作 ，但讀取棧中的數據是隨便的沒有介面約束之說。

很多人都誤解這個理念從而對棧產生困惑。而系統棧在計算機體系結構中又起到一個跨部件交互的媒介區域的作用 即 cpu 與內存的交流通道 ，cpu只從系統給我們自己編寫的應用程序所規定的棧入口線性地讀取執行指令， 用一個形象的詞來形容它就是pipeline。

D. 我現在在學習c語言，入門的課已經通過了，現在在學習一些關於堆棧與隊列，還有一些高級的東西

棧（stack）又名堆棧，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入和刪除運算。這一端被稱為棧頂，相對地，把另一端稱為棧底。向一個棧插入新元物迅素又稱作進棧、入棧或壓棧，它是把新元素放到棧頂元素的上面，使之成為新的棧頂元素；從一個棧刪除元素又稱作出棧或退棧，備茄它是把棧頂元素刪除掉，使其相仿螞察鄰的元素成為新的棧頂元素。隊列是一種特殊的線性表，特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。以上是從數據結構角度來看，從操作系統角度來看，所有的數據結構都是對虛擬內存的操作，堆是堆，棧是棧，棧指的是C語言函數所使用的自動有函數回收的虛擬內存空間，而堆則有操作系統堆管理器來管理的那部分虛擬內存，從C語言角度來看，使用malloc函數動態分配的內存，就是堆內存。

E. 在linux驅動程序中，使用等待隊列的作用

我幫你搜索到如下的回復希望對你有幫助《Linux就該這么學》
概念與術語
1內核裡面的一個隊列，可以將對象加入到隊列中，
2可以選擇條件休眠和無條件休眠，一般情況下是條件休眠用得較多。
3作用：阻塞讀。當運用程序讀數據但是現在還無數據可讀時，往往會先掛起，
4讓其他線程先走，等有數據可讀時再喚醒。
5那麼什麼時候喚醒呢？怎樣喚醒呢？
6這里等待隊列就派上用場了。讀的時候若無數據可讀則加入到等待隊列中，
7寫入的時候喚醒這個隊列。
8可以類比運用程序編程中的pthread_cond_wait()與pthread_cond_broadcast()記憶。
函數介面
include/linux/wait.h

F. 棧和隊列在實際編程中的應用有哪些

模擬遞歸，表達式化成後綴，括弧匹配等等

G. 棧和隊列數據結構的特點,什麼情況下用到棧,什麼情況下用到隊列(各舉3個例子)

棧：特點就是一個先進後出的結構。
隊列：特點就是一個先進先出的結構。
//一般只要你滿足這個特點就可以稱之為棧或隊列。
棧的應用：非常廣泛，在CPU內部就有提供棧這個機制。主要用途：函數調用和返回，數字轉字元，表達式求值，走迷宮等等。在CPU內部棧主要是用來進行子程序調用和返回，中斷時數據保存和返回。在編程語言中：主要用來進行函數的調用和返回。可以說在計算機中，只要數據的保存滿足先進後出的原理，都優先考慮使用棧，所以棧是計算機中不可缺的機制。
隊列的應用：隊列主要用在和時間有關的地方，特別是操作系統中，隊列是實現多任務的重要機制。windows中的消息機制就是通過隊列來實現的。進程調度也是使用隊列來實現，所以隊列也是一個重要的機制。只要滿足數據的先進先出原理就可以使用隊列。

H. 隊列研究的重要性評價怎麼寫

隊列是一種重要的數據結構，它在許多不同的領域都有廣泛的應用。隊列的研究對於我們理解和優化計算機系統的性能具有重要意義。

例如，在計算機網路中，隊列可以用來維護消息的沒沖好傳遞順序，並且在處理海量枯鉛數據時也可以提供有效的存儲方式。隊列在操作系統中也有著廣泛的應用，它可以用來調度進程的執行順序，並且在多線程編程中也可以提供有效的同步機制。

此外，隊列在資料庫系統中也有著重要的作用，它可以用來維護數據的存儲和訪問順序，並且在數據分析和挖掘中也可以提供有效的處理方式判亮。

總的來說，隊列研究對於我們更好地理解和優化計算機系統的性能具有重要意義，因此其重要性是不可忽視的。

I. 求救：棧和隊列在程序設計中的作用

棧和隊列是兩種特殊的線性表，它們的邏輯結構和線性表相同，只是其運算規則較線性表有更多的限制，

故又稱它們為運算受限的線性表。棧和隊列被廣泛應用於各種程序設計中。

棧的定義及基本運算

1、棧的定義

棧（Stack）是限制僅在表的一端進行插入和刪除運算的線性表。

(1)通常稱插入、刪除的這一端為棧頂（Top），另一端稱為棧底（Bottom）。

(2)當表中沒有元素時稱為空棧。

(3)棧為後進先出（Last In First Out）的線性表，簡稱為LIFO 表。

棧的修改是按後進先出的原則進行。每次刪除（退棧）的總是當前棧中"最新"的元素，即最後插入

（進棧）的元素，而最先插入的是被放在棧的底部，要到最後才能刪除。

【示例】元素是以a1，a2，…，an 的順序進棧，退棧的次序卻是an，an-1，…，a1。

2、棧的基本運算

（1）InitStack（S）

構造一個空棧S。

（2）StackEmpty（S）

判棧空。若S 為空棧，則返回TRUE，否則返回FALSE。

（3）StackFull（S）

判棧滿。若S 為滿棧，則返回TRUE，否則返回FALSE。

注意：

該運算只適用於棧的順序存儲結構。

（4）Push（S，x）

進棧。若棧S 不滿，則將元素x 插入S 的棧頂。

（5）Pop（S）

退棧。若棧S 非空，則將S 的棧頂元素刪去，並返回該元素。

（6）StackTop（S）

取棧頂元素。若棧S 非空，則返回棧頂元素，但不改變棧的狀態。

順序棧

棧的順序存儲結構簡稱為順序棧,它是運算受限的順序表。

1、順序棧的類型定義

#define StackSize 100 //假定預分配的棧空間最多為100 個元素

typedef char DataType;//假定棧元素的數據類型為字元

typedef struct{

DataType data[StackSize];

int top;

}SeqStack;

注意：

①順序棧中元素用向量存放

②棧底位置是固定不變的，可設置在向量兩端的任意一個端點

③棧頂位置是隨著進棧和退棧操作而變化的，用一個整型量top（通常稱top 為棧頂指針）來指示

當前棧頂位置

2、順序棧的基本操作

前提條件：

設S 是SeqStack 類型的指針變數。若棧底位置在向量的低端，即S-＞data[0]是棧底元素。

（1） 進棧操作

進棧時，需要將S-＞top 加1

注意：

①S-＞top==StackSize-1 表示棧滿

②"上溢"現象--當棧滿時，再做進棧運算產生空間溢出的現象。

上溢是一種出錯狀態，應設法避免。

（2） 退棧操作

退棧時，需將S-＞top 減1

注意：

①S-＞top<0 表示空棧

②"下溢"現象——當棧空時，做退棧運算產生的溢出現象。

下溢是正常現象，常用作程序控制轉移的條件。

順序棧在進棧和退棧操作時的具體變化情況【參見動畫演示】

3、順序棧的基本運算

（1） 置棧空

void InitStack（SeqStack *S）

{//將順序棧置空

S->top=-1;

}

（2） 判棧空

int StackEmpty（SeqStack *S）

{

return S->top==-1;

}

（3） 判棧滿

int StackFull（SeqStack *SS）

{

return S->top==StackSize-1;

}

（4） 進棧

void Push（S，x）

{

if (StackFull(S))

Error("Stack overflow"); //上溢，退出運行

S->data[++S->top]=x;//棧頂指針加1 後將x 入棧

}

（5） 退棧

DataType Pop（S）

{

if(StackEmpty(S))

Error("Stack underflow"); //下溢，退出運行

return S->data[S->top--];//棧頂元素返回後將棧頂指針減1

}

（6） 取棧頂元素

DataType StackTop（S）

{

if(StackEmpty(S))

Error("Stack is empty");

return S->data[S->top];

}

4、兩個棧共享同一存儲空間

當程序中同時使用兩個棧時，可以將兩個棧的棧底設在向量空間的兩端，讓兩個棧各自向中間延伸。

當一個棧里的元素較多，超過向量空間的一半時，只要另一個棧的元素不多，那麼前者就可以佔用後者的

部分存儲空間。

只有當整個向量空間被兩個棧占滿（即兩個棧頂相遇）時，才會發生上溢。因此，兩個棧共享一個長

度為m 的向量空間和兩個棧分別佔用兩個長度為└ m/2┘和┌m/2┐的向量空間比較，前者發生上溢的概

率比後者要小得多。

鏈棧

棧的鏈式存儲結構稱為鏈棧。

1、鏈棧的類型定義

鏈棧是沒有附加頭結點的運算受限的單鏈表。棧頂指針就是鏈表的頭指針。

鏈棧的類型說明如下：

typedef struct stacknode{

DataType data

struct stacknode *next

}StackNode;

typedef struct{

StackNode *top; //棧頂指針

}LinkStack;

注意：

①LinkStack 結構類型的定義是為了方便在函數體中修改top 指針本身

②若要記錄棧中元素個數，可將元素個數屬性放在LinkStack 類型中定義。

2、鏈棧的基本運算

（1） 置棧空

Void InitStack(LinkStack *S)

{

S->top=NULL;

}

（2） 判棧空

int StackEmpty(LinkStack *S)

{

return S->top==NULL;

}

（3） 進棧

void Push(LinkStack *S,DataType x)

{//將元素x 插入鏈棧頭部

StackNode *p=(StackNode *)malloc(sizeof(StackNode));

p->data=x;

p->next=S->top;//將新結點*p 插入鏈棧頭部

S->top=p;

}

（4） 退棧

DataType Pop(LinkStack *S)

{

DataType x;

StackNode *p=S->top;//保存棧頂指針

if(StackEmpty(S))

Error("Stack underflow."); //下溢

x=p->data; //保存棧頂結點數據

S->top=p->next; //將棧頂結點從鏈上摘下

free(p);

return x;

}

（5） 取棧頂元素

DataType StackTop(LinkStack *S)

{

if(StackEmpty(S))

Error("Stack is empty.")

return S->top->data;

}

注意：

鏈棧中的結點是動態分配的，所以可以不考慮上溢，無須定義StackFull 運算。

--------------------------------------------------------------------------------------------

-----------------

隊列的定義及基本運算

1、定義

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

（1）允許刪除的一端稱為隊頭（Front）。

（2）允許插入的一端稱為隊尾（Rear）。

（3）當隊列中沒有元素時稱為空隊列。

（4）隊列亦稱作先進先出（First In First Out）的線性表，簡稱為FIFO 表。

隊列的修改是依先進先出的原則進行的。新來的成員總是加入隊尾（即不允許"加塞"），每次離開的

成員總是隊列頭上的（不允許中途離隊），即當前"最老的"成員離隊。

【例】在隊列中依次加入元素a1，a2，… ，an 之後，a1 是隊頭元素，an 是隊尾元素。退出隊列的次序

只能是a1，a2，… ，an。

2、隊列的基本邏輯運算

（1）InitQueue（Q）

置空隊。構造一個空隊列Q。

（2）QueueEmpty（Q）

判隊空。若隊列Q 為空，則返回真值，否則返回假值。

（3） QueueFull（Q）

判隊滿。若隊列Q 為滿，則返回真值，否則返回假值。

注意：

此操作只適用於隊列的順序存儲結構。

（4） EnQueue（Q，x）

若隊列Q 非滿，則將元素x 插入Q 的隊尾。此操作簡稱入隊。

（5） DeQueue（Q）

若隊列Q 非空，則刪去Q 的隊頭元素，並返回該元素。此操作簡稱出隊。

（6） QueueFront（Q）

若隊列Q 非空，則返回隊頭元素，但不改變隊列Q 的狀態。

順序隊列

1、順序隊列

（1）順序隊列的定義

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

（2） 順序隊列的表示

①和順序表一樣，順序隊列用一個向量空間來存放當前隊列中的元素。

②由於隊列的隊頭和隊尾的位置是變化的，設置兩個指針front 和rear 分別指示隊頭元素和隊尾元素

在向量空間中的位置，它們的初值在隊列初始化時均應置為0。

（3） 順序隊列的基本操作

①入隊時：將新元素插入rear 所指的位置，然後將rear 加1。

②出隊時：刪去front 所指的元素，然後將front 加1 並返回被刪元素。

注意：

①當頭尾指針相等時，隊列為空。

②在非空隊列里，隊頭指針始終指向隊頭元素，尾指針始終指向隊尾元素的下一位置。

順序隊列基本操作【參見動畫演示】

（4）順序隊列中的溢出現象

① "下溢"現象

當隊列為空時，做出隊運算產生的溢出現象。「下溢」是正常現象，常用作程序控制轉移的條件。

② "真上溢"現象

當隊列滿時，做進棧運算產生空間溢出的現象。「真上溢」是一種出錯狀態，應設法避免。

③ "假上溢"現象

由於入隊和出隊操作中，頭尾指針只增加不減小，致使被刪元素的空間永遠無法重新利用。當隊列中

實際的元素個數遠遠小於向量空間的規模時，也可能由於尾指針已超越向量空間的上界而不能做入隊操作。

該現象稱為"假上溢"現象。

【例】假設下述操作序列作用在初始為空的順序隊列上：

EnQueue，DeQueue，EnQueue，DeQueue，…

盡管在任何時刻，隊列元素的個數均不超過1，但是只要該序列足夠長，事先定義的向量空間無論多大

均會產生指針越界錯誤。

鏈隊列

1、鏈隊列的定義

隊列的鏈式存儲結構簡稱為鏈隊列。它是限制僅在表頭刪除和表尾插入的單鏈表。

2、鏈隊列的結構類型說明

注意：

增加指向鏈表上的最後一個結點的尾指針，便於在表尾做插入操作。

鏈隊列示意圖見上圖，圖中Q 為LinkQueue 型的指針。

3、鏈隊列的基本運算

（1） 置空隊

void InitQueue(LinkQueue *Q)

{

Q->front=Q->rear=NULL;

}

（2） 判隊空

intQueueEmpty(LinkQueue *Q)

{

return Q->front==NULL&&Q->rear==Null;

//實際上只須判斷隊頭指針是否為空即可

}

（3） 入隊

void EnQueue(LinkQueue *Q,DataType x)

{//將元素x 插入鏈隊列尾部

QueueNode *p=(QueueNode *)malloc(sizeof(QueueNode));//申請新結點

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

if(QueueEmpty(Q))

Q->front=Q->rear=p; //將x 插入空隊列

else { //x 插入非空隊列的尾

Q->rear->next=p; //*p 鏈到原隊尾結點後

Q->rear=p; //隊尾指針指向新的尾

}

}

（4） 出隊

DataType DeQueue (LinkQueue *Q)

{

DataType x;

QueueNode *p;

if(QueueEmpty(Q))

Error("Queue underflow");//下溢

p=Q->front; //指向對頭結點

x=p->data; //保存對頭結點的數據

Q->front=p->next; //將對頭結點從鏈上摘下

if(Q->rear==p)//原隊中只有一個結點，刪去後隊列變空，此時隊頭指針已為空

Q->rear=NULL;

free(p); //釋放被刪隊頭結點

return x; //返回原隊頭數據

}

（5） 取隊頭元素

DataType QueueFront(LinkQueue *Q)

{

if(QueueEmpty(Q))

Error("Queue if empty.");

return Q->front->data;

}

注意：

①和鏈棧類似，無須考慮判隊滿的運算及上溢。

②在出隊演算法中，一般只需修改隊頭指針。但當原隊中只有一個結點時，該結點既是隊頭也是隊尾，

故刪去此結點時亦需修改尾指針，且刪去此結點後隊列變空。

③以上討論的是無頭結點鏈隊列的基本運算。和單鏈表類似，為了簡化邊界條件的處理，在隊頭結點

前也可附加一個頭結點，增加頭結點的鏈隊列的基本運算【參見練習】

循環隊列

為充分利用向量空間，克服"假上溢"現象的方法是：將向量空間想像為一個首尾相接的圓環，並稱這

種向量為循環向量。存儲在其中的隊列稱為循環隊列（Circular Queue）。

（1） 循環隊列的基本操作

循環隊列中進行出隊、入隊操作時，頭尾指針仍要加1，朝前移動。只不過當頭尾指針指向向量上界

（QueueSize-1）時，其加1 操作的結果是指向向量的下界0。這種循環意義下的加1 操作可以描述為：

① 方法一：

if(i+1==QueueSize) //i 表示front 或rear

i=0;

else

i++;

② 方法二--利用"模運算"

i=(i+1)%QueueSize；

（2） 循環隊列邊界條件處理

循環隊列中，由於入隊時尾指針向前追趕頭指針；出隊時頭指針向前追趕尾指針，造成隊空和隊滿時

頭尾指針均相等。因此，無法通過條件front==rear 來判別隊列是"空"還是"滿"。【參見動畫演示】

解決這個問題的方法至少有三種：

① 另設一布爾變數以區別隊列的空和滿；

② 少用一個元素的空間。約定入隊前，測試尾指針在循環意義下加1 後是否等於頭指針，若相等則認

為隊滿（注意：rear 所指的單元始終為空）；

③使用一個計數器記錄隊列中元素的總數（即隊列長度）。

（3） 循環隊列的類型定義

#define Queur Size 100 //應根據具體情況定義該值

typedef char Queue DataType; //DataType 的類型依賴於具體的應用

typedef Sturet{ //頭指針，隊非空時指向隊頭元素

int front; //尾指針，隊非空時指向隊尾元素的下一位置

int rear; //計數器，記錄隊中元素總數

DataType data[QueueSize]

}CirQueue;

（4） 循環隊列的基本運算

用第三種方法，循環隊列的六種基本運算：

① 置隊空

void InitQueue(CirQueue *Q)

{

Q->front=Q->rear=0;

Q->count=0; //計數器置0

}

② 判隊空

int QueueEmpty(CirQueue *Q)

{

return Q->count==0; //隊列無元素為空

}

③ 判隊滿

int QueueFull(CirQueue *Q)

{

return Q->count==QueueSize; //隊中元素個數等於QueueSize 時隊滿

}

④ 入隊

void EnQueue(CirQueuq *Q,DataType x)

{

if(QueueFull((Q))

Error("Queue overflow"); //隊滿上溢

Q->count ++; //隊列元素個數加1

Q->data[Q->rear]=x; //新元素插入隊尾

Q->rear=(Q->rear+1)%QueueSize; //循環意義下將尾指針加1

⑤ 出隊

DataType DeQueue(CirQueue *Q)

{

DataType temp;

if(QueueEmpty((Q))

Error("Queue underflow"); //隊空下溢

temp=Q->data[Q->front];

Q->count--; //隊列元素個數減1

Q->front=(Q->front+1)&QueueSize; //循環意義下的頭指針加1

return temp;

}

⑥取隊頭元素

DataType QueueFront(CirQueue *Q)

{

if(QueueEmpty(Q))

Error("Queue if empty.");

return Q->data[Q->front];

}

J. 編程為什麼要使用棧結構而不要隊列

用棧大多是為了保存現場,比如在遞歸消除中,在二叉樹前中後遍歷中.

而隊列大多是為了保存一個狀態,一邊出隊一邊進隊進行掃描,比如二叉樹的層次遍歷以及圖的BFS.

兩者各有各的用處,而可以很明顯的觀察到,前者的用途要比後者廣泛一些.

編程是一段很有意思的旅程,LZ加油