堆（Heap）與棧（Stack）是開發(fā)人員必須面對的兩個(gè)概念，在理解這兩個(gè)概念時(shí)，需要放到具體的場景下，因?yàn)椴煌瑘鼍跋?#xff0c;堆與棧代表不同的含義。一般情況下，有兩層含義：?
（1）程序內(nèi)存布局場景下，堆與棧表示的是兩種內(nèi)存管理方式；?
（2）數(shù)據(jù)結(jié)構(gòu)場景下，堆與棧表示兩種常用的數(shù)據(jù)結(jié)構(gòu)。

1.程序內(nèi)存分區(qū)中的堆與棧
1.1棧簡介
棧由操作系統(tǒng)自動分配釋放 ，用于存放函數(shù)的參數(shù)值、局部變量等，其操作方式類似于數(shù)據(jù)結(jié)構(gòu)中的棧。參考如下代碼：

int main() {int b; ? ? ? ? ? ? ?//棧char s[] = "abc"; ? //棧char *p2; ? ? ? ? ? //棧 }

其中函數(shù)中定義的局部變量按照先后定義的順序依次壓入棧中，也就是說相鄰變量的地址之間不會存在其它變量。棧的內(nèi)存地址生長方向與堆相反，由高到底，所以后定義的變量地址低于先定義的變量，比如上面代碼中變量s的地址小于變量b的地址，p2地址小于s的地址。棧中存儲的數(shù)據(jù)的生命周期隨著函數(shù)的執(zhí)行完成而結(jié)束。

1.2堆簡介
堆由程序員分配釋放， 若程序員不釋放，程序結(jié)束時(shí)由OS回收，分配方式倒是類似于鏈表。參考如下代碼：

int main() {//C中使用malloc函數(shù)申請char* p1 = (char *)malloc(10);cout<<(int*)p1<<endl; ? ? ? //輸出：00000000003BA0C0//使用free()釋放free(p1);//C++中用new運(yùn)算符申請char p2 = new char[10];cout<<(int*)p2<<endl; ? ? ? //輸出：00000000003BA0C0//使用delete運(yùn)算符釋放delete[] p2;}

其中p1所指的10字節(jié)的內(nèi)存空間與p2所指的10字節(jié)內(nèi)存空間都是存在于堆的。堆的內(nèi)存地址生長方向與棧相反，由低到高，但需要注意的是，后申請的內(nèi)存空間并不一定在先申請的內(nèi)存空間的后面，即p2指向的地址并不一定大于p1所指向的內(nèi)存地址，原因是先申請的內(nèi)存空間一旦被釋放，后申請的內(nèi)存空間則會利用先前被釋放的內(nèi)存，從而導(dǎo)致先后分配的內(nèi)存空間在地址上不存在先后關(guān)系。堆中存儲的數(shù)據(jù)的若未釋放，則其生命周期等同于程序的生命周期。

關(guān)于堆上內(nèi)存空間的分配過程，首先應(yīng)該知道操作系統(tǒng)有一個(gè)記錄空閑內(nèi)存地址的鏈表，當(dāng)系統(tǒng)收到程序的申請時(shí)，會遍歷該鏈表，尋 找第一個(gè)空間大于所申請空間的堆結(jié)點(diǎn)，然后將該結(jié)點(diǎn)從空閑結(jié)點(diǎn)鏈表中刪除，并將該結(jié)點(diǎn)的空間分配給程序，另外，對于大多數(shù)系統(tǒng)，會在這塊內(nèi)存空間中的首地址處記錄本次分配的大小，這樣，代碼中的delete語句才能正確的釋放本內(nèi)存空間。另外，由于找到的堆結(jié)點(diǎn)的大小不一定正好等于申請的大小，系統(tǒng)會自動的將多余的那部分重新放入空閑鏈表中。

2.3堆與棧區(qū)別
堆與棧實(shí)際上是操作系統(tǒng)對進(jìn)程占用的內(nèi)存空間的兩種管理方式，主要有如下幾種區(qū)別：?
（1）管理方式不同。棧由操作系統(tǒng)自動分配釋放，無需我們手動控制；堆的申請和釋放工作由程序員控制，容易產(chǎn)生內(nèi)存泄漏；?
（2）空間大小不同。每個(gè)進(jìn)程擁有的棧的大小要遠(yuǎn)遠(yuǎn)小于堆的大小。理論上，程序員可申請的堆大小為虛擬內(nèi)存的大小，進(jìn)程棧的大小64bits的Windows默認(rèn)1M，64bits的Linux默認(rèn)10M；?
（3）生長方向不同。堆的生長方向向上，內(nèi)存地址由低到高；棧的生長方向向下，內(nèi)存地址由高到低。?
（4）分配方式不同。堆都是動態(tài)分配的，沒有靜態(tài)分配的堆。棧有2種分配方式：靜態(tài)分配和動態(tài)分配。靜態(tài)分配是由操作系統(tǒng)完成的，比如局部變量的分配。動態(tài)分配由alloca函數(shù)進(jìn)行分配，但是棧的動態(tài)分配和堆是不同的，他的動態(tài)分配是由操作系統(tǒng)進(jìn)行釋放，無需我們手工實(shí)現(xiàn)。?
（5）分配效率不同。棧由操作系統(tǒng)自動分配，會在硬件層級對棧提供支持：分配專門的寄存器存放棧的地址，壓棧出棧都有專門的指令執(zhí)行，這就決定了棧的效率比較高。堆則是由C/C++提供的庫函數(shù)或運(yùn)算符來完成申請與管理，實(shí)現(xiàn)機(jī)制較為復(fù)雜，頻繁的內(nèi)存申請容易產(chǎn)生內(nèi)存碎片。顯然，堆的效率比棧要低得多。?
（6）存放內(nèi)容不同。棧存放的內(nèi)容，函數(shù)返回地址、相關(guān)參數(shù)、局部變量和寄存器內(nèi)容等。當(dāng)主函數(shù)調(diào)用另外一個(gè)函數(shù)的時(shí)候，要對當(dāng)前函數(shù)執(zhí)行斷點(diǎn)進(jìn)行保存，需要使用棧來實(shí)現(xiàn)，首先入棧的是主函數(shù)下一條語句的地址，即擴(kuò)展指針寄存器的內(nèi)存（eip），然后是當(dāng)前棧幀的底部地址，即擴(kuò)展基址指針寄存器內(nèi)容（ebp），再然后是被調(diào)函數(shù)的實(shí)參等，一般情況下是按照從右向左的順序入棧，之后是調(diào)用函數(shù)的局部變量，注意靜態(tài)變量是存放在數(shù)據(jù)段或者BSS段，是不入棧的。出棧的順序正好相反，最終棧頂指向主函數(shù)下一條語句的地址，主程序又從該地址開始執(zhí)行。堆，一般情況堆頂使用一個(gè)字節(jié)的空間來存放堆的大小，而堆中具體存放內(nèi)容是由程序員來填充的。

從以上可以看到，堆和棧相比，由于大量malloc()/free()或new/delete的使用，容易造成大量的內(nèi)存碎片，并且可能引發(fā)用戶態(tài)和核心態(tài)的切換，效率較低。棧相比于堆，在程序中應(yīng)用較為廣泛，最常見的是函數(shù)的調(diào)用過程由棧來實(shí)現(xiàn)，函數(shù)返回地址、EBP、實(shí)參和局部變量都采用棧的方式存放。雖然棧有眾多的好處，但是由于和堆相比不是那么靈活，有時(shí)候分配大量的內(nèi)存空間，主要還是用堆。

無論是堆還是棧，在內(nèi)存使用時(shí)都要防止非法越界，越界導(dǎo)致的非法內(nèi)存訪問可能會摧毀程序的堆、棧數(shù)據(jù)，輕則導(dǎo)致程序運(yùn)行處于不確定狀態(tài)，獲取不到預(yù)期結(jié)果，重則導(dǎo)致程序異常崩潰，這些都是我們編程時(shí)與內(nèi)存打交道時(shí)應(yīng)該注意的問題。

2.數(shù)據(jù)結(jié)構(gòu)中的堆與棧
數(shù)據(jù)結(jié)構(gòu)中，堆與棧是兩個(gè)常見的數(shù)據(jù)結(jié)構(gòu)，理解二者的定義、用法與區(qū)別，能夠利用堆與棧解決很多實(shí)際問題。

2.1棧簡介
棧是一種運(yùn)算受限的線性表，其限制是指只僅允許在表的一端進(jìn)行插入和刪除操作，這一端被稱為棧頂（Top），相對地，把另一端稱為棧底（Bottom）。把新元素放到棧頂元素的上面，使之成為新的棧頂元素稱作進(jìn)棧、入棧或壓棧（Push）；把棧頂元素刪除，使其相鄰的元素成為新的棧頂元素稱作出棧或退棧（Pop）。這種受限的運(yùn)算使棧擁有“先進(jìn)后出”的特性（First In Last Out），簡稱FILO。

棧分順序棧和鏈?zhǔn)綏煞N。棧是一種線性結(jié)構(gòu)，所以可以使用數(shù)組或鏈表（單向鏈表、雙向鏈表或循環(huán)鏈表）作為底層數(shù)據(jù)結(jié)構(gòu)。使用數(shù)組實(shí)現(xiàn)的棧叫做順序棧，使用鏈表實(shí)現(xiàn)的棧叫做鏈?zhǔn)綏?#xff0c;二者的區(qū)別是順序棧中的元素地址連續(xù)，鏈?zhǔn)綏Ｖ械脑氐刂凡贿B續(xù)。

棧的結(jié)構(gòu)如下圖所示：?

棧的基本操作包括初始化、判斷棧是否為空、入棧、出棧以及獲取棧頂元素等。下面以順序棧為例，使用C語言給出一個(gè)簡單的實(shí)現(xiàn)。

#include<stdio.h> #include<malloc.h>#define DataType int #define MAXSIZE 1024 struct SeqStack {DataType data[MAXSIZE];int top; };//棧初始化,成功返回棧對象指針，失敗返回空指針NULL SeqStack* initSeqStack() {SeqStack* s=(SeqStack*)malloc(sizeof(SeqStack));if(!s){printf("空間不足\n");return NULL;}else{s->top = -1;return s;} }

?
//判斷棧是否為空

bool isEmptySeqStack(SeqStack* s) {if (s->top == -1)return true;elsereturn false; }//入棧，返回-1失敗，0成功 int pushSeqStack(SeqStack* s, DataType x) {if(s->top == MAXSIZE-1){return -1;//棧滿不能入棧}else{s->top++;s->data[s->top] = x;return 0;} }

?
//出棧，返回-1失敗，0成功

int popSeqStack(SeqStack* s, DataType* x) {if(isEmptySeqStack(s)){return -1;//棧空不能出棧}else{*x = s->data[s->top];s->top--;return 0;} }

?
//取棧頂元素，返回-1失敗，0成功

int topSeqStack(SeqStack* s,DataType* x) {if (isEmptySeqStack(s))return -1;//棧空else{*x=s->data[s->top];return 0;} }

?
//打印棧中元素

int printSeqStack(SeqStack* s) {int i;printf("當(dāng)前棧中的元素:\n");for (i = s->top; i >= 0; i--)printf("%4d",s->data[i]);printf("\n");return 0; }

?
//test

int main() {SeqStack* seqStack=initSeqStack();if(seqStack){//將4、5、7分別入棧pushSeqStack(seqStack,4);pushSeqStack(seqStack,5);pushSeqStack(seqStack,7);//打印棧內(nèi)所有元素printSeqStack(seqStack);//獲取棧頂元素DataType x=0;int ret=topSeqStack(seqStack,&x);if(0==ret){printf("top element is %d\n",x);}//將棧頂元素出棧ret=popSeqStack(seqStack,&x);if(0==ret){printf("pop top element is %d\n",x);}}return 0; }

運(yùn)行上面的程序，輸出結(jié)果：

當(dāng)前棧中的元素:
? ?7 ? 5 ? 4
top element is 7
pop top element is 7

2.2堆簡介
2.2.1堆的性質(zhì)
堆是一種常用的樹形結(jié)構(gòu)，是一種特殊的完全二叉樹，當(dāng)且僅當(dāng)滿足所有節(jié)點(diǎn)的值總是不大于或不小于其父節(jié)點(diǎn)的值的完全二叉樹被稱之為堆。堆的這一特性稱之為堆序性。因此，在一個(gè)堆中，根節(jié)點(diǎn)是最大（或最小）節(jié)點(diǎn)。如果根節(jié)點(diǎn)最小，稱之為小頂堆（或小根堆），如果根節(jié)點(diǎn)最大，稱之為大頂堆（或大根堆）。堆的左右孩子沒有大小的順序。下面是一個(gè)小頂堆示例：?

堆的存儲一般都用數(shù)組來存儲堆，i結(jié)點(diǎn)的父結(jié)點(diǎn)下標(biāo)就為。它的左右子結(jié)點(diǎn)下標(biāo)分別為??和?。如第0個(gè)結(jié)點(diǎn)左右子結(jié)點(diǎn)下標(biāo)分別為1和2。?

2.2.2堆的基本操作
（1）建立?
以最小堆為例，如果以數(shù)組存儲元素時(shí)，一個(gè)數(shù)組具有對應(yīng)的樹表示形式，但樹并不滿足堆的條件，需要重新排列元素，可以建立“堆化”的樹。?

（2）插入?
將一個(gè)新元素插入到表尾，即數(shù)組末尾時(shí)，如果新構(gòu)成的二叉樹不滿足堆的性質(zhì)，需要重新排列元素，下圖演示了插入15時(shí)，堆的調(diào)整。?

（3）刪除。?
堆排序中，刪除一個(gè)元素總是發(fā)生在堆頂，因?yàn)槎秧數(shù)脑厥亲钚〉?#xff08;小頂堆中）。表中最后一個(gè)元素用來填補(bǔ)空缺位置，結(jié)果樹被更新以滿足堆條件。?

2.2.3堆操作實(shí)現(xiàn)
（1）插入代碼實(shí)現(xiàn)?
每次插入都是將新數(shù)據(jù)放在數(shù)組最后。可以發(fā)現(xiàn)從這個(gè)新數(shù)據(jù)的父結(jié)點(diǎn)到根結(jié)點(diǎn)必然為一個(gè)有序的數(shù)列，現(xiàn)在的任務(wù)是將這個(gè)新數(shù)據(jù)插入到這個(gè)有序數(shù)據(jù)中，這就類似于直接插入排序中將一個(gè)數(shù)據(jù)并入到有序區(qū)間中，這是節(jié)點(diǎn)“上浮”調(diào)整。不難寫出插入一個(gè)新數(shù)據(jù)時(shí)堆的調(diào)整代碼：

//新加入i結(jié)點(diǎn),其父結(jié)點(diǎn)為(i-1)/2
//參數(shù)：a：數(shù)組，i：新插入元素在數(shù)組中的下標(biāo) ?

void minHeapFixUp(int a[], int i) ? { ?int j, temp; ?temp = a[i]; ?j = (i-1)/2; ? ? ?//父結(jié)點(diǎn) ?while (j >= 0 && i != 0) ?{ ?if (a[j] <= temp)//如果父節(jié)點(diǎn)不大于新插入的元素，停止尋找 ?break; ?a[i]=a[j]; ? ? //把較大的子結(jié)點(diǎn)往下移動,替換它的子結(jié)點(diǎn) ?i = j; ?j = (i-1)/2; ?} ?a[i] = temp; ? } ?

因此，插入數(shù)據(jù)到最小堆時(shí)：

//在最小堆中加入新的數(shù)據(jù)data ?
//a：數(shù)組，index：插入的下標(biāo)，

void minHeapAddNumber(int a[], int index, int data) ? { ?a[index] = data; ?minHeapFixUp(a, index); ? }?

（2）刪除代碼實(shí)現(xiàn)?
按定義，堆中每次都只能刪除第0個(gè)數(shù)據(jù)。為了便于重建堆，實(shí)際的操作是將數(shù)組最后一個(gè)數(shù)據(jù)與根結(jié)點(diǎn)，然后再從根結(jié)點(diǎn)開始進(jìn)行一次從上向下的調(diào)整。

調(diào)整時(shí)先在左右兒子結(jié)點(diǎn)中找最小的，如果父結(jié)點(diǎn)不大于這個(gè)最小的子結(jié)點(diǎn)說明不需要調(diào)整了，反之將最小的子節(jié)點(diǎn)換到父結(jié)點(diǎn)的位置。此時(shí)父節(jié)點(diǎn)實(shí)際上并不需要換到最小子節(jié)點(diǎn)的位置，因?yàn)檫@不是父節(jié)點(diǎn)的最終位置。但邏輯上父節(jié)點(diǎn)替換了最小的子節(jié)點(diǎn)，然后再考慮父節(jié)點(diǎn)對后面的結(jié)點(diǎn)的影響。相當(dāng)于從根結(jié)點(diǎn)將一個(gè)數(shù)據(jù)的“下沉”過程。下面給出代碼：

//a為數(shù)組，從index節(jié)點(diǎn)開始調(diào)整,len為節(jié)點(diǎn)總數(shù) 從0開始計(jì)算index節(jié)點(diǎn)的子節(jié)點(diǎn)為 2*index+1, 2*index+2,len/2-1為最后一個(gè)非葉子節(jié)點(diǎn) ?

void minHeapFixDown(int a[],int len,int index) {if(index>(len/2-1))//index為葉子節(jié)點(diǎn)不用調(diào)整return;int tmp=a[index];lastIndex=index;while(index<=len/2-1) ? ? ? ?//當(dāng)下沉到葉子節(jié)點(diǎn)時(shí)，就不用調(diào)整了{(lán)?if(a[2*index+1]<tmp) ? ? //如果左子節(jié)點(diǎn)小于待調(diào)整節(jié)點(diǎn){lastIndex = 2*index+1;}//如果存在右子節(jié)點(diǎn)且小于左子節(jié)點(diǎn)和待調(diào)整節(jié)點(diǎn)if(2*index+2<len && a[2*index+2]<a[2*index+1]&& a[2*index+2]<tmp){lastIndex=2*index+2;}//如果左右子節(jié)點(diǎn)有一個(gè)小于待調(diào)整節(jié)點(diǎn)，選擇最小子節(jié)點(diǎn)進(jìn)行上浮if(lastIndex!=index)?{ ?a[index]=a[lastIndex];index=lastIndex;}else break; ? ? ? ? ? ? //否則待調(diào)整節(jié)點(diǎn)不用下沉調(diào)整}a[lastIndex]=tmp; ? ? ? ? ? //將待調(diào)整節(jié)點(diǎn)放到最后的位置 }

根據(jù)思想，可以有不同版本的代碼實(shí)現(xiàn)，以上是和孫凜同學(xué)一起討論出的一個(gè)版本，在這里感謝他的參與，讀者可另行給出。個(gè)人體會，這里建議大家根據(jù)對堆調(diào)整過程的理解，寫出自己的代碼，切勿看示例代碼去理解算法，而是理解算法思想寫出代碼，否則很快就會忘記。

（3）建堆?
有了堆的插入和刪除后，再考慮下如何對一個(gè)數(shù)據(jù)進(jìn)行堆化操作。要一個(gè)一個(gè)的從數(shù)組中取出數(shù)據(jù)來建立堆吧，不用！先看一個(gè)數(shù)組，如下圖：?

很明顯，對葉子結(jié)點(diǎn)來說，可以認(rèn)為它已經(jīng)是一個(gè)合法的堆了即20，60， 65， 4， 49都分別是一個(gè)合法的堆。只要從A[4]=50開始向下調(diào)整就可以了。然后再取A[3]=30，A[2] = 17，A[1] = 12，A[0] = 9分別作一次向下調(diào)整操作就可以了。下圖展示了這些步驟：?

寫出堆化數(shù)組的代碼：

//建立最小堆
//a:數(shù)組，n：數(shù)組長度

void makeMinHeap(int a[], int n) ? { ?for (int i = n/2-1; i >= 0; i--) ?minHeapFixDown(a, i, n); ? } ?

2.2.4 堆的具體應(yīng)用——堆排序
堆排序（Heapsort）是堆的一個(gè)經(jīng)典應(yīng)用，有了上面對堆的了解，不難實(shí)現(xiàn)堆排序。由于堆也是用數(shù)組來存儲的，故對數(shù)組進(jìn)行堆化后，第一次將A[0]與A[n - 1]交換，再對A[0…n-2]重新恢復(fù)堆。第二次將A[0]與A[n – 2]交換，再對A[0…n - 3]重新恢復(fù)堆，重復(fù)這樣的操作直到A[0]與A[1]交換。由于每次都是將最小的數(shù)據(jù)并入到后面的有序區(qū)間，故操作完成后整個(gè)數(shù)組就有序了。有點(diǎn)類似于直接選擇排序。

因此，完成堆排序并沒有用到前面說明的插入操作，只用到了建堆和節(jié)點(diǎn)向下調(diào)整的操作，堆排序的操作如下：

//array:待排序數(shù)組，len：數(shù)組長度

void heapSort(int array[],int len) {//建堆makeMinHeap(array,len);?//最后一個(gè)葉子節(jié)點(diǎn)和根節(jié)點(diǎn)交換，并進(jìn)行堆調(diào)整，交換次數(shù)為len-1次for(int i=len-1;i>0;--i){//最后一個(gè)葉子節(jié)點(diǎn)交換array[i]=array[i]+array[0];array[0]=array[i]-array[0];array[i]=array[i]-array[0];//堆調(diào)整minHeapFixDown(array, 0, len-i-1); ?} } ?

（1）穩(wěn)定性?
堆排序是不穩(wěn)定排序。

（2）堆排序性能分析?
由于每次重新恢復(fù)堆的時(shí)間復(fù)雜度為O(logN)，共N - 1次堆調(diào)整操作，再加上前面建立堆時(shí)N / 2次向下調(diào)整，每次調(diào)整時(shí)間復(fù)雜度也為O(logN)。兩次次操作時(shí)間相加還是O(N * logN)。故堆排序的時(shí)間復(fù)雜度為O(N * logN)。

最壞情況：如果待排序數(shù)組是有序的，仍然需要O(N * logN)復(fù)雜度的比較操作，只是少了移動的操作；

最好情況：如果待排序數(shù)組是逆序的，不僅需要O(N * logN)復(fù)雜度的比較操作，而且需要O(N * logN)復(fù)雜度的交換操作。總的時(shí)間復(fù)雜度還是O(N * logN)。

因此，堆排序和快速排序在效率上是差不多的，但是堆排序一般優(yōu)于快速排序的重要一點(diǎn)是數(shù)據(jù)的初始分布情況對堆排序的效率沒有大的影響。
?

?

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

轉(zhuǎn)載后的自己總結(jié):

堆就是你開辟一個(gè)新變量(new malloc),棧就是你保存程序的跳轉(zhuǎn)地址的時(shí)候用到棧,

用戶角度就是你吐槽:我的電腦怎么這么卡,當(dāng)內(nèi)存引起卡頓的時(shí)候,那么這些卡頓就是由于堆棧引起的.

另外,注意堆和客棧的結(jié)合使用:

被調(diào)用函數(shù)的跳轉(zhuǎn)地址是棧保存的,但是被調(diào)用函數(shù)里面臨時(shí)建立的變量是堆內(nèi)存.

?

[2]

那么如果該被調(diào)用函數(shù)是在類中呢?

這種時(shí)候方法中的成員變量的引用是在堆內(nèi)存中

?

棧的后進(jìn)先出,體現(xiàn)在,你最晚調(diào)用的函數(shù)必須最先跳出(返回)

?

堆的關(guān)鍵就是指針,指針就是地址,其實(shí)所有編程語言都有指針,只要有變量就有地址,有地址就有指針,但是你可以反駁啊,你說python沒有指針.其實(shí)是有的,只不過沒放到臺面上來,沒有明講.

堆的設(shè)計(jì)就是讀入讀出,可以是D觸發(fā)器也可以是Flash(閃存)

棧則在硬件底層直接支持

?

?

Reference:

[1]Java類中的成員變量引用放在堆區(qū)還是棧區(qū)？注意，不是在方法

總結(jié)

以上是生活随笔為你收集整理的堆和栈的区别(转载)+自己总结的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。