寫在前面：本文僅供個人學習使用。《大話數據結構》通俗易懂，適合整體做筆記輸出，構建體系。并且文中很多圖片來源于該書。

文章目錄

• • 4.2棧的定義
  • • 4.2.1 棧的定義
    • 4.2.2 進棧出棧變化形式
  • 4.3 棧的抽象數據類型
  • 4.4 棧的順序存儲結構及實現
  • • 4.4.1 棧的順序存儲結構
    • 4.4.2 棧的順序存儲結構---進棧操作
    • 4.4.3 棧的順序存儲結構--出棧操作
  • 4.5兩棧共享空間
  • 4.6棧的鏈式存儲結構及實現
  • • 4.6.1 棧的鏈式存儲結構
    • 4.6.2 棧的鏈式存儲結構---進棧操作
    • 4.6.3 棧的鏈式存儲結構--出棧操作
  • 4.7 棧的應用
  • 4.8棧的應用--遞歸
  • • 4.8.1 斐波那契數列實現
    • 4.8.2遞歸定義
  • 4.9棧的應用--四則運算表達式求值
  • • 4.9.1 后綴（逆波蘭式）表示法定義
    • 4.9.2 后綴表達式計算結果
    • 4.9.3 中綴表達式轉后綴表達式
  • 4.10 隊列的定義
  • 4.11 隊列的抽象數據類型
  • 4.12 循環隊列
  • 4.13 隊列的鏈式存儲結構及實現
  • 4.14總結回顧

棧與隊列：
1 棧是限定僅在表尾進行插入和刪除操作的線性表。
2 隊列是指允許在一端進行插入操作、而在另一端進行刪除操作的線性表。

4.2棧的定義

4.2.1 棧的定義

棧是類似彈夾中的子彈一樣先進去、后出來；而后進的，反而可以先出來。

在軟件應用中，棧這種后進先出的數據結構的應用是非常普遍的。比如用瀏覽器上網時，不管什么瀏覽器都有一個 “后退”鍵，點擊后就可以按訪問順序的逆序加載瀏覽過的網頁。 很多類似的軟件，比如word、ps等文檔或圖像編輯軟件中，都有撤銷的操作，也是用棧這種方式來實現的。棧(stack)是限定僅在表尾進行插入和刪除操作的線性表。

我們把允許插入和刪除的一端稱為棧頂（top），另一端稱為棧底(bottom)，不含任何數據元素的棧稱為空棧。加粗樣式棧又稱為后進先出(Last In First Out)的線性表，簡稱LIFO結構。

理解棧的定義需要注意：
首先它是一個線性表，也就是說，棧元素具有線性關系，即前驅后繼關系。只不過它是一種特殊的線性表而已。定義中說是在線性表的表尾進行插入和刪除操作，這里的表尾是指棧頂，而不是棧底。

它的特殊之處就在于限制了這個線性表的插入和刪除位置，它始終只在棧頂進行。這也就使得：棧底是固定的，最先進棧的只能在棧底。

棧的插入操作，叫做進棧，也稱壓棧、入棧。棧的刪除操作，叫做出棧，也有的叫彈棧。

4.2.2 進棧出棧變化形式

現在的問題是：最先進棧的元素，是不是只能最后出棧呢？

答案是不一定，要看什么情況。棧對線性表的插入和刪除的位置進行了限制，丙沒有對元素進出的時間進行限制，也就是說，在不是所有元素都進棧的情況下，事先進去的元素也可以出棧，只要保證是棧頂元素出棧就可以。

舉例來說，如果我們現在是有3個整型數字元素1、2、3依次進棧，會有哪些出棧次序呢？

• 第一種：1、2、3進棧，再3、2、1出棧。這是最簡單的也是最好理解的一種，出棧次序為321.
• 第二種：1進、1出、2進、2出、3進、3出。也就是進一個出一個，出棧次序為123.
• 第三種：1進、2進、2出、1出、3進、3出。出棧次序為213.
• 第四種：1進、1出、2進、3進、3出、2出。出棧次序為：132.
• 第五種：1進、2進、2出、3進、3出、1出。出棧次序為231.

有沒有可能是312這樣的次序出棧呢？答案是肯定不會的。因為3先出棧，就意味著，3曾經進棧，既然3都進棧了，那也就意味著，1和2已經進棧了，此時，2一定是在1的上面，就是更接近棧頂，那么出棧情況只能是321，不然不滿足123依次進棧的要求，所以此時不會發生1比2先出棧的情況。

從這個簡單的例子就能看出，只是3個元素，就有5種可能的出棧次序，如果元素數量多，其實出棧的變化將會更多。這個知識點一定要弄明白。

4.3 棧的抽象數據類型

對于棧來說，理論上線性表的操作特性它都具備，可由于它的特殊性，所以針對它在操作上會有些變化。特別是插入和刪除操作，我們改名為push和pop，英文直譯的話是壓和彈，更容易理解。一般叫做入棧和出棧。

ADT 棧(stack) Data同線性表。元素具有相同的類型，相鄰元素具有前驅和后繼的關系。 OperationInitStack(*S):初始化操作，建立一個空棧SDestroyStack(*S):若棧存在，則銷毀它。ClearStack(*S):將棧清空StackEmpty(S):若棧為空，返回true；否則返回falseGetTop(S,*e):若棧存在且非空，用e返回S的棧頂元素Push(*S,*e):若棧S存在，插入新元素e到棧S中并成為棧頂元素Pop(*S,*e):刪除棧S中棧頂元素，并用e返回其值StackLength(S):返回棧S的元素個數 endADT

由于棧本身就是一個線性表，那么我們上一章討論了線性表的順序存儲和鏈式存儲，對于棧來說，也是同樣適用的。

4.4 棧的順序存儲結構及實現

4.4.1 棧的順序存儲結構

既然棧是線性表的特例，那么棧的順序存儲其實也是線性表順序存儲的簡化，我們簡稱為順序棧。線性表使用數組來實現的，想想看，對于棧這種只能一端插入刪除的線性表來說，用數組的哪一端作為棧頂和棧底比較好？

對，沒錯，下標為0的一端作為棧底比較好，因為首元素都存在棧底，變化最小，所以讓它作棧底。

我們定義一個top變量來指示棧頂元素在數組中的位置，可以變大變小，但是不餓能超過范圍。如果存儲棧的長度為StackSize，則棧頂位置top必須小于StackSize，當棧存在一個元素時，top=0，因此通常把空棧的判定條件定為top等于-1.

來看棧的結構定義

typedef int SElemType/ typedef struct{SElemType data[MAXSIZE];int top;//用于棧頂指針}SqStack;

若現在有一個棧，StackSize是5，則棧普通情況、空棧和棧滿的情況示意圖如圖所示。

4.4.2 棧的順序存儲結構—進棧操作

對于棧的插入，即進棧操作，其實就是棧頂指針上移

因此對于入棧操作push，代碼如下

//插入數據元素e為棧的棧頂元素Status Push(SqStack *S,SElemType e){if(S->top==MAXSIZE-1) return ERROR; //棧滿S->top++;S->data[S->top]=e; 將新插入的元素賦值給棧頂空間return OK;}

4.4.3 棧的順序存儲結構–出棧操作

出棧操作pop，代碼如下

//若棧不空，則刪除S的棧頂元素，用e返回其值。并返回OK；否則返回ERRORStatus Pop(SqStack *S,SElemType *e){if(S->top==-1) return ERROR;*e=S->data[S->top]; S->top--;return OK;}

入棧和出棧沒有涉及任何循環結構，因此時間復雜度為O(1).

4.5兩棧共享空間

其實棧的順序存儲還是很方便的，因為它只準棧頂進出元素，所以不存在線性表插入和刪除時需要移動元素的問題。不過它有一個很大的缺陷，就是必須事先確定數組存儲空間的大小，萬一不夠用了，就需要編程手段來擴展數組的容量，非常麻煩。對于一個棧，我們只能盡量考慮周全，設計出合適大小的數組來處理，但對于兩個相同類型的棧，我們卻可以做到最大限度地利用其事先開辟的存儲空間來進行操作。

打個比方，兩個大學室友畢業同時來上海找工作，開始時，他們覺得住了這么多年學校的集體宿舍，現在工作了一定要有自己的私密空間。于是他們都希望租房時能找到獨居的一居室，可找來找去卻發現，最便宜的一居室也要每月1500元，地段還不好，實在承受不起，最終他倆還是合租了一套兩居室，一共2000元，各出一半，還不錯。

對于兩個一居室，都有獨立的衛生間和廚房，是私密了，但大部分空間的利用率卻不高。而兩居室，兩個人各有臥室，還共享了客廳、廚房和衛生間，房間的利用率就顯著提高了，而且租房成本也大大下降了。

同樣的道理，如果我們有兩個相同類型的棧，我們為它們各自開辟了數組空間，極有可能是第一個棧已經滿了，再進棧就溢出了，而另一個棧還有很多存儲空間空閑。這又何必呢？我們完全可以用一個數組來存儲兩個棧，只不過需要點小技巧。

我們的做法如下圖所示，數組有兩個端點，兩個棧有兩個棧底，讓一個棧的棧底為數組的始端，即下標為0的地方，另一個棧為數組的末端，即下標n-1處。這樣，兩個棧如果增加元素，就是兩端點向中間延伸。

其實關鍵思路是：它們是數組的兩端，向中間靠攏。top1 和top2是棧1和棧2的棧頂指針，可以想象，只要它們倆不見面，兩個棧就可以一直使用。

從這里可以分析出來，棧1為空時，就是top1等于-1時；而當top2等于n時，即是棧2為空時，那什么時候棧滿呢？

想想極端的情況，若棧2是空棧，棧1的top1等于n-1時，就是棧1滿了。反之，當棧1為空棧時，top2等于0時，為棧2滿。但更多的情況，兩個棧見面之時，也就是兩個指針相差1時，即top1+1==top2時為棧滿。

兩棧共享空間的結構代碼如下

typedef struct{SElemType data[MAXSIZE];int top1;int top2;//指針}SqDoubleStack;

對于兩棧共享空間的push方法，我們除了要插入元素值參數外，還需要有一個判斷是棧1還是棧2的棧號參數stackNumber。插入元素的代碼如下

Status Push(SqDoubleStack *S,SElemType e,int stackNumber){if(S->top1+1==S->top2) return ERROR;//棧滿if(stackNumber==1) //棧1有元素進棧S->data[++S->top1]=e;//++top1是先加再賦值else if(stackNumber==2)//棧2有元素進棧S->data[--S->top2]=e; //top2先-1 然后給數組元素賦值return OK; }

對于兩棧共享空間的pop方法，參數就只是判斷棧1棧2的參數stackNumber，代碼如下:

status Pop(SqDoubleStack *S,SElemType *e,int stackNumber){if(stackNumber==1){if(S->top1==-1) return ERROR;*e=S->data[S->top1--];先取出S->top1處的值，再--}else if(stackNumber==2){if(S->top2==MAXSIZE) return ERROR;*e=S->data[S->top2++];}return OK; }

事實上，使用這樣的數據結構，通常都是當兩個棧的空間需求有相反關系時，也就是一個棧增長時另一個棧在縮短的情況。

另外，這只是針對兩個具有相同數據類型的棧的一個設計上的技巧。如果是不同的數據類型的棧，這種辦法不但不嫩更好地處理問題，反而會使問題變得更復雜，大家要注意這個前提。

4.6棧的鏈式存儲結構及實現

4.6.1 棧的鏈式存儲結構

講完了棧的順序存儲結構，我們現在看看棧的鏈式存儲結構，簡稱為鏈棧。
想想看，棧只是棧頂來做插入和刪除操作，棧頂放在鏈表的頭部還是尾部呢？由于單鏈表有頭指針，而棧頂指針也是必須的，那干嘛不讓它倆合二為一呢，所以比較好的辦法是把棧頂放在單鏈表的頭部。另外，都已經有了棧頂在頭部了，單鏈表種比較常用的頭結點也就失去了意義，通常對于鏈棧來說，是不需要頭結點的。

對于鏈棧來說，基本不存在棧滿的情況，除非內存沒有可用空間的時候。但對于空棧來說，鏈表原定義是頭指針指向空，那么鏈棧的空其實就是top==NULL的時候。
鏈棧的結構代碼如下

typedef struct{SElemType data;//數據元素struct StackNode *next;//指針 }StackNode,*LinkStackPtr;typedef struct{LinkStackPtr top;//頭指針int count;//結點數量 }LinkStack;

鏈棧的操作絕大部分都和單鏈表類似，只是在插入和刪除上，特殊一些。

4.6.2 棧的鏈式存儲結構—進棧操作

對于鏈棧的進棧push操作，假設元素值為e的新結點是s，top為棧頂指針，如下圖

//插入元素e為新的棧頂元素 Status Push(LinkStack *S,SElemType e){LinkStackPtr s=(LinkStackPtr)malloc(sizeof(StackNode));//新結點s->data=e;s->next=S->top;S->top=s;S->count++;return OK;}

4.6.3 棧的鏈式存儲結構–出棧操作

至于鏈棧的出棧pop操作，也是很簡單的三句操作。假設變量p用來存儲要刪除的棧頂結點，將棧頂指針下移一位，最后釋放p即可。

Status Pop(LinkStack *S ,SElemType *e){LinkStackPtr p;if(StackEmpty(*S)) return ERROR;*e=S->top->data;p=S->top;//將棧頂元素賦給pS->top=S->top->next; //棧頂下移free(p); //釋放結點pS->count--;return OK; }

鏈棧的進棧和出棧的時間復雜度都是O(1).

對比一下順序棧和鏈棧，它們在時間復雜度上都是O(1).對于空間性能，順序棧需要事先確定一個固定的長度，可能會存在內存空間浪費的情況，但它的優勢是存取是定位很方便，而鏈棧要求每個元素都有指針域，這同時也增加了一些內存開銷，但對于棧的長度無限制。所以它們的區別和線性表中討論的一樣，如果棧的使用過程中元素變化不可預料，有時很小，有時非常大，那么最好用鏈棧，反之，如果它的變化在可控的范圍內，建議使用順序棧會更好一些。

4.7 棧的應用

棧的引入簡化了程序設計的問題，劃分了不同關注層次，使得思考范圍縮小，更加聚焦于我們要解決的問題核心。反之，像數組等，因為要分散精力去考慮數組下標增減等細節問題，反而掩蓋了問題的本質。

所以現在許多高級語言，比如Java，C#等都有對棧結構的封裝，可以不用關心它的實現細節，就可以直接使用Stack的push和pop 方法，非常方便。

4.8棧的應用–遞歸

4.8.1 斐波那契數列實現

說如果兔子在出生之后，就有繁殖能力，一對兔子每個月能生出一對小兔子來。假設所有兔子都不死，那么一年以后可以繁殖多少對兔子？

表中數字1，1，2，3，5，8，13，21，34，55，89，144……構成了一個序列。這個數列有個十分明顯的特點，那是：前面相鄰兩項之和，構成了后一項。

先考慮一下，如果我們要實現這樣的數列用常規的迭代的辦法如何實現？假設我們要打印前40位的斐波那契數列，代碼如下

int main(){int i;int a[40];a[0]=0,a[1]=1;printf("%d",a[0]); printf("%d",a[1]);for(i=2;i<40;i++){a[i]=a[i-1]+a[i-2];printf("%d",a[i]);}return 0; }

代碼很簡單，不用做任何解釋，但其實我們的代碼，如果用遞歸來實現，還可以更簡單。

int Fbi(int i){if(i<2) return i==0 ? 0 :1;reuturn Fbi(i-1)+Fbi(i-2); }int main(){int i;for(i=0;i<40;i++) printf("%d",Fbi(i));return 0;}

我們來模擬代碼中的Fbi(5)的情況

4.8.2遞歸定義

在高級語言中，調用自己和調用其他函數并沒有本質區別。我們把一個直接調用自己或通過一系列的調用語句間接地調用自己的函數，稱作遞歸函數。

當然，寫遞歸程序最怕的就是陷入永不結束的無窮遞歸中，所以，每個遞歸定義必須至少有一個條件，滿足時遞歸不再進行，即不再引用自身而是返回值退出。

對比了兩次實現斐波那契數列的代碼。迭代和遞歸的區別是：迭代使用的是循環結構，遞歸使用的是選擇結構。遞歸能使程序的結構更清晰、更簡潔、更容易讓人理解，從而減少讀懂代碼的時間。但是大量的遞歸調用會建立函數的副本，會耗費大量的時間和內存。迭代則不需要反復調用函數和占用額外的內存。因此我們應該視不同的情況選擇不同的代碼實現方式。

那么我們講了這么多遞歸的內容，和棧有什么關系呢？這得從計算機系統的內部說起。

前面我們已經看到遞歸是如何執行它的前行和退回階段的。遞歸過程退回的順序是它前行順序的逆序。在退回過程中，可能要執行某些動作，包括恢復在前行過程中存儲起來的某些數據。

這種存儲某些數據，并在后面又以存儲的逆序恢復這些數據，以提供之后使用的需求，顯然很符合棧這樣的數據結構，因此，編譯器使用棧實現遞歸就沒有什么好驚訝的了。

簡單地說，就是在前行階段，對于每一層遞歸，函數的局部變量、參數值以及返回地址都被壓入棧中。在退回階段，位于棧頂的局部變量、參數值和返回地址被彈出，用于返回調用層次中執行代碼的其余部分，也就是恢復了調用的狀態。

4.9棧的應用–四則運算表達式求值

4.9.1 后綴（逆波蘭式）表示法定義

如果讓你用C語言或其他高級語言實現對數學表達式的求值，你打算怎樣做？

這里面的困難就在于乘除在加減的后面，卻先要運算，而加入了括號后，就變得更加復雜。不知道該如何處理。

但仔細觀察后發現，括號都是成對出現的，有左括號就一定會有右括號，對于多重括號，最終也是完全嵌套匹配的。這用棧結構正好合適，只有碰到左括號，就將此左括號進棧，不管表達式有多少重括號，反正遇到左括號就進棧，而后面出現右括號時，就讓棧頂的左括號出棧，期間讓數字運算，這樣，最終有括號的表達式從左到右巡查一遍，棧應該是由空到有元素，最終再因全部匹配成功后成為空棧的結果。

20世紀50年代，波蘭邏輯學家Jan想到了一種不需要括號的后綴表達式，我們也把它稱為逆波蘭式(Reverse Polish Notation,RPN)表示。 這種后綴表達式，是表達式的一種新的顯示方式，非常巧妙地解決了程序實現四則運算的難題。

我們先來看看，對于“9+(3-1)*3 +10 /2”,如果用后綴表達式應該是什么樣子：”9 3 1 - 3 * + 10 2 / +“ ，這樣的表達式稱為后綴表達式，叫后綴的原因在于所有的符號都是在要運算數字的后面出現的。

4.9.2 后綴表達式計算結果

為了解釋后綴表達式的好處，我們先來看看，計算機如何應用后綴表達式計算出最終的結果20的。

后綴表達式：9 3 1 - 3 * + 10 2 / +

規則：從左到右遍歷表達式的每個數字和符號，遇到數字就進棧，遇到是符號，就將處于棧頂兩個數字出棧，進行運算，運算結果進棧，一直到最終獲得結果。

1 初始化一個空棧。此棧用來對要運算的數字進出使用。如4-9-1左圖所示。
2 后綴表達式中前三個都是數字，所以9，3，1進棧，如圖所示

3 接下來是”-“，所以將棧中的1出棧作為減數，3出棧作為被減數，并運算得到2，再將2進棧，如圖4-9-2左圖所示
4 接著是數字3進棧，如圖49-2右圖所示

5 后面是”*“，也就意味著棧中3和2出棧，2與3相乘，得到6，并將6進棧，如圖4-9-3左圖所示。

6 下面是”+“，所以棧中6和9出棧，9和6相加，得到15，將15入棧，如圖4-9-3右圖所示

7 接下來是10與2兩數字進棧，如圖4-9-4左圖所示
8 接下來是符號”/“，因此，棧頂的2與10出棧，10與2相除，得到5，將5進棧，如圖4-9-4右圖所示

9 最后一個是符號”+“，所以15與5出棧并相加，得到20，將20進棧，如圖4-9-5左圖所示。
10 結果是20出棧，棧變為空，如圖4-9-5右圖所示

果然，后綴表達式可以很順利地解決計算的問題。現在的問題是，這個后綴表達式”9 3 1 - 3 * + 10 2 / +“是怎么來的？這個問題沒搞清楚，等于沒有解決。所以下面，我們就來推導如何讓”9+(3-1)*3 +10 /2“ 轉化為”9 3 1 - 3 * + 10 2 / +“

4.9.3 中綴表達式轉后綴表達式

我們把平時所用的標準四則運算表達式，即”9+(3-1)*3 +10 /2“這樣的表達式，叫做中綴表達式。因為所有的運算符號都在兩數字的中間，現在我們的問題就是中綴到后綴的轉化。

中綴表達式 ”9+(3-1)*3 +10 /2“ 轉化為后綴表達式 ”9 3 1 - 3 * + 10 2 / +“ 。

規則：從左到右遍歷中綴表達式的每個數字和符號，若是數字就輸出，即成為后綴表達式的一部分；若是符號，則判斷其與棧頂符號的優先級，是右括號或優先級低于棧頂符號（乘除優先加減）則棧頂元素依次出棧并輸出，并將當前符號進棧，一直到最終輸出后綴表達式為止。

1 初始化一空棧，用來對符號進出棧使用。如圖4-9-6左圖所示。

2 第一個字符是數字9 ，輸出9 ，后面的字符是符號”+“，進棧。如圖4-9-6右圖所示。

3 第三個字符是”（“，依然是符號，因其只是左括號，還未配對，故進棧。如圖4-9-7左圖所示。
4 第四個字符是數字3，輸出，總表達式為 9 3，接著是”-“，進棧，如圖4-9-7右圖所示。

5 接下來是數字1，輸出，總表達式為 9 3 1，后面是符號”）“，此時，我們需要去匹配此前的"("，所以棧頂依次出棧，并輸出，直到”（“出棧為止。此時左括號上方只有”-“，因此輸出”-“。總的輸出表達式為 9 3 1 -。如圖4-9-8左圖所示。

6 接著是符號” *“,因為此時的棧頂符號為”+“號，新來的” * “優先級高于棧頂符號，因此不輸出，" * "入棧。接著是數字3，輸出，總的表達式為 9 3 1 - 3.如圖4-9-8右圖所示。

7 之后是符號”+“，當前棧頂元素”* “ 比這個”+“ 的優先級高，因此棧中元素出棧并輸出（沒有比”+“號更低的優先級，所以全部出棧），總輸出表達式為 9 3 1 - 3 * +。然后將當前這個符號”+“ 入棧。如圖4-9-9左圖所示。

8 緊接著是數字10 ，輸出，總表達式變為 9 3 1 - 3 * + 10 .之后是符號”/“，所以”/“進棧。如圖4-9-9右圖所示。
9 最后一個數字2，輸出，總的表達式為9 3 1 - 3 * + 10 2。如圖4-9-10左圖所示。

10 因已經到達最后，所以將棧中符號全部出棧并輸出。最終輸出的后綴表達式結果為9 3 1 - 3 * + 10 2 / + 。如圖4-9-10右圖所示。

從剛才的推導中你會發現，要想讓計算機具有處理我們通常的中綴表達式的能力，最重要的就是兩步：

將中綴表達式轉化為后綴表達式(棧用來進出運算的符號)。

將后綴表達式進行運算得出結果（棧用來進出運算的數字）。

整個過程，都充分利用了棧的后進先出特性來處理，理解好它其實也就理解好了棧這個數據結構。

4.10 隊列的定義

(待填坑！！！)

你們用電腦時有沒有經歷過，機器有時會處于疑似死機的狀態，鼠標點什么似乎都沒有用，雙擊任何快捷方式都不動彈。就當你失去耐心，打算reset時，它突然像酒醒了一樣，把你剛才點擊的所有操作全部都按順序執行了一遍。這其實是因為操作系統中的多個程序因需要通過一個通道輸出，而按先后次序排隊等待造成的。

4.11 隊列的抽象數據類型

4.12 循環隊列

4.13 隊列的鏈式存儲結構及實現

4.14總結回顧

總結

以上是生活随笔為你收集整理的《大话数据结构》读书笔记-栈与队列的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。