堆（Heap）與棧（Stack）是開發人員必須面對的兩個概念，在理解這兩個概念時，需要放到具體的場景下，因為不同場景下，堆與棧代表不同的含義。一般情況下，有兩層含義：?
（1）程序內存布局場景下，堆與棧表示的是兩種內存管理方式；?
（2）數據結構場景下，堆與棧表示兩種常用的數據結構。

1.程序內存分區中的堆與棧
1.1棧簡介
棧由操作系統自動分配釋放 ，用于存放函數的參數值、局部變量等，其操作方式類似于數據結構中的棧。參考如下代碼：

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

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

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

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

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

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

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

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

無論是堆還是棧，在內存使用時都要防止非法越界，越界導致的非法內存訪問可能會摧毀程序的堆、棧數據，輕則導致程序運行處于不確定狀態，獲取不到預期結果，重則導致程序異常崩潰，這些都是我們編程時與內存打交道時應該注意的問題。

2.數據結構中的堆與棧
數據結構中，堆與棧是兩個常見的數據結構，理解二者的定義、用法與區別，能夠利用堆與棧解決很多實際問題。

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

棧分順序棧和鏈式棧兩種。棧是一種線性結構，所以可以使用數組或鏈表（單向鏈表、雙向鏈表或循環鏈表）作為底層數據結構。使用數組實現的棧叫做順序棧，使用鏈表實現的棧叫做鏈式棧，二者的區別是順序棧中的元素地址連續，鏈式棧中的元素地址不連續。

棧的結構如下圖所示：?

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

#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("當前棧中的元素:\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);//打印棧內所有元素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; }

運行上面的程序，輸出結果：

當前棧中的元素:
? ?7 ? 5 ? 4
top element is 7
pop top element is 7

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

堆的存儲一般都用數組來存儲堆，i結點的父結點下標就為。它的左右子結點下標分別為??和?。如第0個結點左右子結點下標分別為1和2。?

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

（2）插入?
將一個新元素插入到表尾，即數組末尾時，如果新構成的二叉樹不滿足堆的性質，需要重新排列元素，下圖演示了插入15時，堆的調整。?

（3）刪除。?
堆排序中，刪除一個元素總是發生在堆頂，因為堆頂的元素是最小的（小頂堆中）。表中最后一個元素用來填補空缺位置，結果樹被更新以滿足堆條件。?

2.2.3堆操作實現
（1）插入代碼實現?
每次插入都是將新數據放在數組最后?？梢园l現從這個新數據的父結點到根結點必然為一個有序的數列，現在的任務是將這個新數據插入到這個有序數據中，這就類似于直接插入排序中將一個數據并入到有序區間中，這是節點“上浮”調整。不難寫出插入一個新數據時堆的調整代碼：

//新加入i結點,其父結點為(i-1)/2
//參數：a：數組，i：新插入元素在數組中的下標 ?

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

因此，插入數據到最小堆時：

//在最小堆中加入新的數據data ?
//a：數組，index：插入的下標，

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

（2）刪除代碼實現?
按定義，堆中每次都只能刪除第0個數據。為了便于重建堆，實際的操作是將數組最后一個數據與根結點，然后再從根結點開始進行一次從上向下的調整。

調整時先在左右兒子結點中找最小的，如果父結點不大于這個最小的子結點說明不需要調整了，反之將最小的子節點換到父結點的位置。此時父節點實際上并不需要換到最小子節點的位置，因為這不是父節點的最終位置。但邏輯上父節點替換了最小的子節點，然后再考慮父節點對后面的結點的影響。相當于從根結點將一個數據的“下沉”過程。下面給出代碼：

//a為數組，從index節點開始調整,len為節點總數 從0開始計算index節點的子節點為 2*index+1, 2*index+2,len/2-1為最后一個非葉子節點 ?

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

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

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

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

寫出堆化數組的代碼：

//建立最小堆
//a:數組，n：數組長度

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

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

因此，完成堆排序并沒有用到前面說明的插入操作，只用到了建堆和節點向下調整的操作，堆排序的操作如下：

//array:待排序數組，len：數組長度

void heapSort(int array[],int len) {//建堆makeMinHeap(array,len);?//最后一個葉子節點和根節點交換，并進行堆調整，交換次數為len-1次for(int i=len-1;i>0;--i){//最后一個葉子節點交換array[i]=array[i]+array[0];array[0]=array[i]-array[0];array[i]=array[i]-array[0];//堆調整minHeapFixDown(array, 0, len-i-1); ?} } ?

（1）穩定性?
堆排序是不穩定排序。

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

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

最好情況：如果待排序數組是逆序的，不僅需要O(N * logN)復雜度的比較操作，而且需要O(N * logN)復雜度的交換操作?？偟臅r間復雜度還是O(N * logN)。

因此，堆排序和快速排序在效率上是差不多的，但是堆排序一般優于快速排序的重要一點是數據的初始分布情況對堆排序的效率沒有大的影響。
?

?

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

轉載后的自己總結:

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

用戶角度就是你吐槽:我的電腦怎么這么卡,當內存引起卡頓的時候,那么這些卡頓就是由于堆棧引起的.

另外,注意堆和客棧的結合使用:

被調用函數的跳轉地址是棧保存的,但是被調用函數里面臨時建立的變量是堆內存.

?

[2]

那么如果該被調用函數是在類中呢?

這種時候方法中的成員變量的引用是在堆內存中

?

棧的后進先出,體現在,你最晚調用的函數必須最先跳出(返回)

?

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

堆的設計就是讀入讀出,可以是D觸發器也可以是Flash(閃存)

棧則在硬件底層直接支持

?

?

Reference:

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

總結

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

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