堆和棧的解釋和區別

ZHUO_SIR發表於2018-07-11

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

1.程式記憶體分割槽中的堆與棧

1.1棧簡介

棧由作業系統自動分配釋放 ，用於存放函式的引數值、區域性變數等，其操作方式類似於資料結構中的棧。參考如下程式碼：

int main()
{
    int b;              //棧
    char s[] = "abc";   //棧
    char *p2;           //棧
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

其中函式中定義的區域性變數按照先後定義的順序依次壓入棧中，也就是說相鄰變數的地址之間不會存在其它變數。棧的記憶體地址生長方向與堆相反，由高到底，所以後定義的變數地址低於先定義的變數，比如上面程式碼中變數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;


}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

其中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）。把新元素放到棧頂元素的上面，使之成為新的棧頂元素稱作進棧、入棧或壓棧（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;
    else
        return 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;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120

執行上面的程式，輸出結果：

當前棧中的元素:
   7   5   4
top element is 7
pop top element is 7
  • 1
  • 2
  • 3
  • 4

2.2堆簡介

2.2.1堆的性質

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

堆的儲存一般都用陣列來儲存堆，i結點的父結點下標就為(i–1)/2(i–1)/2。它的左右子結點下標分別為 2∗i+12∗i+1 和 2∗i+22∗i+2。如第0個結點左右子結點下標分別為1和2。 
這裡寫圖片描述

2.2.2堆的基本操作

（1）建立 
以最小堆為例，如果以陣列儲存元素時，一個陣列具有對應的樹表示形式，但樹並不滿足堆的條件，需要重新排列元素，可以建立“堆化”的樹。 
這裡寫圖片描述

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

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

2.2.3堆操作實現

（1）插入程式碼實現 
每次插入都是將新資料放在陣列最後。可以發現從這個新資料的父結點到根結點必然為一個有序的數列，現在的任務是將這個新資料插入到這個有序資料中，這就類似於直接插入排序中將一個資料併入到有序區間中，這是節點“上浮”調整。不難寫出插入一個新資料時堆的調整程式碼：

//新加入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;  
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

因此，插入資料到最小堆時：

//在最小堆中加入新的資料data  
//a：陣列，index：插入的下標，
void minHeapAddNumber(int a[], int index, int data)  
{  
    a[index] = data;  
    minHeapFixUp(a, index);  
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

（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;           //將待調整節點放到最後的位置
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

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

（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);  
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

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
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

（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)複雜度的交換操作。總的時間複雜度還是O(N * logN)。

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

相關文章