算法與數據結構（4）：堆排序

堆排序（HeapSort）是最經常使用的排序算法之一。這種排序算法同時具備插入排序和歸併排序的優勢。與插入排序同樣，具備空間原址性，即任什麼時候候都只須要常數個額外的空間儲存臨時數據（對此，請你們回想一下歸併排序，隨着問題規模的越大，須要的額外空間就越大，在解決大型問題時，這是不可接受的缺點）。與歸併排序同樣，具備 \(O(n*lgn)\) 的時間複雜度。

其實一句話總結，堆排序具備 \(O(1)\) 的空間複雜度，具備 \(O(n*lgn)\) 的時間複雜度。

同時，在這裏須要強調一點，此文所說的堆是一種數據結構，其相似於咱們上一篇文章所說的樹，在一些高級語言中，例如 Java 中，「堆」是一種「垃圾收集存儲機制」，這僅僅是由於 Java 的 「垃圾收集存儲機制」 最先的數據結構採用的是「堆」。由於這個系列是介紹算法與數據結構的，因此此係列後續提到的全部「堆」，都是隻一種數據結構，但願讀者在自行了解相關知識時，注意區分。

此文堆排序的完整代碼能夠在個人github上查看。

堆

以下圖所示，（二叉）堆能夠被理解爲一個徹底二叉樹：

一般狀況下，咱們採用數組來存儲（雖然咱們也能夠採用上一篇文章中提到的樹來實現，但這必然會帶來額外的複雜度。雖然咱們採用數組實現，但在理解時請將其視爲樹，查看註釋）。

除了最底層外，該樹是徹底充滿的，並且最底層是從左往右依次填充。表示堆的數組應該包括兩個屬性，heap_length 和 heap_size ，其中 heap_length 表示數組總長度，heap_size 表示有效數據個數，同時知足 \(0 \leq heap\_size \leq length\) 。爲了方便寫代碼，咱們以下定義：

#define HEAP_LENGTH 20 // 數組長度

int array_to_sort[HEAP_LENGTH + 1] = {HEAP_LENGTH, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
                                      20, 19, 18, 17, 16, 15, 14, 13, 12, 11};

咱們將 array_to_sort[0] 解釋爲 heap_size，故 array_to_sort 的實際長度應爲 heap_length + 1。這樣作的目的實際上是爲了下文方便，給定一個節點下標 i ，那麼他的父節點，左孩子和右孩子節點下標分別爲：

#define PARENT(i) (i / 2)
#define LEFT(i) (2 * i)
#define RIGHT(i) (2 * i + 1)

對於大多數的計算機而言，經過將 i 的值算數左移一位，便可在一條指令內計算出 2i，將 i 的值算數右移一位，便可在一條指令內計算出 \(\lfloor \frac{i}{2} \rfloor\) ，不過在現代編譯器中，編譯器會自動將乘2與除2運算自動優化爲移位操做，因此咱們在寫代碼時若是須要乘除法，儘可能只進行乘2與除2操做便可。

二叉堆能夠分爲兩種形式：最大堆和最小堆。最小堆是指 除了根節點之外的其餘全部節點 i 都須要知足：

\[A[PARENT(i)] \leq A[i] \]

即某個節點的值至多與其父節點同樣小，所以堆中的最小元素存放在根節點中，而且此樹的任意子樹中，該子樹的中的全部元素的最小值也在子樹的根節點。最大堆與此正好相反，是指 除了根節點之外的全部節點 i 都有：

\[A[PARENT(i)] \geq A[i] \]

此文中採用的堆排序使用最大堆。

若是咱們把堆當作一棵樹，則堆中某個節點的高度爲該節點到葉節點的最長簡單路徑上的邊的數量，而堆的高度爲根節點的高度。

下文的代碼中，會涉及到swap函數，咱們先將此函數的代碼展現一下：

// 交換數組array的 下標i 和 下標j 對應的值
int swap(int *array, int i, int j){
    int temp;
    temp = array[i];
    array[i] = array[j];
    array[j] = temp;
    return 0;
}

維護堆

首先展現一下代碼：

// 遞歸維護最大堆
int MaintainMaxHeap(int *heap, int i){
    int largest;
    int left = LEFT(i);
    int right = RIGHT(i);
    if(left <= heap[0] && heap[left] > heap[i]){
        largest = left;
    } else{
        largest = i;
    }
    if(right <= heap[0] && heap[right] > heap[largest]){
        largest = right;
    }
    if(largest != i){
        swap(heap, largest, i);
        MaintainMaxHeap(heap, largest);
    }
    return 0;
}

此函數的做用是維護最大堆的性質。函數的輸入爲一個堆（數組）heap，一個下標 i 。調用前，調用者須要保證根節點爲 LEAT(i) 和 RIGHT(i) 的二叉樹都是最大堆（具體保證方法下文會闡述），此時咱們須要將如下標 i 爲根節點的子樹修改成最大堆（由於heap[i] 可能小於 heap[LEFT(i)] 或 heap[RIGHT(i)] ）。

在代碼中，咱們從 heap[i] 和 heap[LEFT(i)] 、heap[RIGHT(i)] 中選出值最大的數，將其下標儲存在 largest 中。若heap[i] 就是最大值，說明此堆已經符合最大堆的特性，無需進行其餘操做；反之則將 heap[i] 與 heap[largest] 交換，交換後，下標爲largest的節點是原來的 heap[i]，以此節點爲根節點的子樹有可能也會違反最大堆的特性，那麼咱們此時只需再對此節點調用一次 MaintainMaxHeap() 函數，如此遞歸下去，完成堆的維護。

時間複雜度

對於一棵以 i 爲根節點，大小爲 n 的子樹，MaintainMaxHeap() 的時間消耗分爲兩部分：調整 heap[i]，heap[LEFT(i)]，heap[RIGHT(i)] ，代價爲 \(\Theta(1)\) ；若進行了交換，維護 i 節點的一個子樹的時間（時間複雜度通常指最壞狀況，因此咱們須要假定遞歸調用會發生）。而每個孩子的子樹大小至多爲 \(\frac{2n}{3}\) （取最壞狀況，樹的底層正好半滿，即左子樹的深度正比如右子樹大1，且左子樹是一個徹底二叉樹），那麼，運行一次 MaintainMaxHeap() 的時間消耗爲：

\[T(n) \leq T(\frac{2n}{3}) + \Theta(1) \]

由主定理可得，上述遞歸式的解爲 \(T(n)=O(lgn)\) 。

建堆

上文咱們提到，在維護堆的性質時，須要保證左右子樹均爲最大堆，那麼最爲簡單的方法就是讓整個堆都變成最大堆，這樣，若是替換了一個數，他的左右子樹必能保證爲一個最大堆。

對此，咱們採用自底向上的方法，把一個大小爲 n 的數組轉換爲最大堆。

// 建堆
int BuildHeap(int *heap){
    int i;
    for(i = PARENT(heap[0]); i >= 1; i--){
        MaintainMaxHeap(heap, i);
    }
    return 0;
}

正確性分析

初始化：在第一次循環之前，\(i=\lfloor \frac{n}{2} \rfloor\) ，而 \(\lfloor \frac{n + 1}{2} \rfloor\) ， \(\lfloor \frac{n + 2}{2} \rfloor\) ，... ，\(n\) 都是葉節點，故下標大於 i 的節點都是一個最大堆的根節點。

保持：由於節點 i 的孩子節點下標均大於 i ，故以節點 i 的子節點爲根節點的樹都是一個最大堆，因此咱們能夠對節點 i 調用 MaintainMaxHeap() 函數，調用完成後，以節點 i 爲根節點的樹是一個最大堆，其餘下標大於 i 的節點要麼不受影響，要麼在 MaintainMaxHeap() 函數中，依然保持了最大堆的性質。一次循環結束，i 自減，此時下標大於 i 的節點都是一個最大堆的根節點。

終止：循環結束時，i==0，那麼此時下標大於 0 的節點都是一個最大堆的根節點，即整個樹已經成爲了一個最大堆（heap[0]中儲存的是 heap_size，不是堆中的元素，但願各位讀者不要忘記了）。

時間複雜度

對於這個過程，咱們能夠進行簡單的估算。每次調用 MaintainMaxHeap() 函數，其時間複雜度不超過 \(O(lgn)\) ，MaintainMaxHeap() 函數一共被調用 \(O(n)\) 次，那麼其時間複雜度不超過 \(O(n*lgn)\) 。這個上界雖然正確，但不夠精確。咱們下面來進行一下進一步的分析（若是讀者的數學水平有限的話，能夠暫時跳過下面的具體分析）。

首先，對於一個含 \(n\) 個元素的堆，其高度爲 \(\lfloor lgn \rfloor\) ，其中高度爲 \(h\) 的節點，最多有 \(\lceil \frac{n}{2^{h+1}} \rceil\) 個（請各位讀者再仔細看一下上文的關於堆的高度的概念，以前教朋友的時候，不少人是把概念都弄錯了，從而以爲是我這個地方算錯了2333）

在一個高度爲 \(h\) 的節點上運行 MaintainMaxHeap() 的時間複雜度是 \(O(h)\) ，那麼 BuildHeap() 的總的時間複雜度爲

\[\sum_{h=0}^{\lfloor lgn \rfloor} {\lceil \frac{n}{2^{h+1}} \rceil}O(h) = O(n \sum_{h=0}^{\lfloor lgn \rfloor} {\frac{h}{2^h}} ) \]

使用無窮級數或者數列的知識，咱們能夠獲得：

\[\sum_{h=0}^{ \infty } {\frac{h}{2^h}} = \frac{1/2}{(1-1/2)^2} = 2 \]

那麼最終的時間複雜度爲：

\[O(n \sum_{h=0}^{\lfloor lgn \rfloor} {\frac{h}{2^h}} ) = O(n \sum_{h=0}^{ \infty } {\frac{h}{2^h}}) = O(2n) = O(n) \]

沒想到吧，咱們竟然能夠在線性時間內，把一個無序數組構造爲一個最大堆。

堆排序

前面鋪墊了這麼多，終於進入正題了，如何進行堆排序？

// 堆排序
int HeapSort(int *heap){
    int i;
    BuildHeap(heap);
    for(i = heap[0]; i >= 1; i--){
        swap(heap, 1, heap[0]);
        heap[0] -= 1;
        MaintainMaxHeap(heap, 1);
    }
}

步驟很是簡單，首先創建一個最大堆，那麼此時數組中的最大元素就在根節點 heap[1] ，此時咱們將其與 heap[heap_size] 交換，咱們便可將此元素放在正確的位置（最終的排序效果爲遞增），此時咱們將 heap_size 減一，將剛纔被選出的最大值從堆中去掉。對於此時的堆，根節點的兩個子樹依然保持着最大堆的特性，但根節點可能會違背最大堆的特性，此時咱們調用 MaintainMaxHeap(heap, 1) 便可將其從新轉換爲一個最大堆，重複此操做，直到將全部節點均從堆中去掉，那麼整個數組也就排序完成了。

時間複雜度

堆排序的第一步是創建一個最大堆，其時間複雜度咱們已經在上文分析了，爲 \(O(n)\) 。

調用 n 次 MaintainMaxHeap()，每次的時間複雜度爲 \(O(lgn)\) 。

那麼總的時間複雜度爲 \(O(n*lgn)\) 。

不過此時可能就會有好奇的讀者問了，在建堆的過程當中，須要調用 \(n\) 次，每次複雜度不超過 \(O(lgn)\) ，這不是和堆排序是同樣的嗎？爲何建堆最後算出來時間複雜度是 \(O(n)\) ，而堆排序就是 \(O(n*lgn)\) 呢？是的，關於堆排序的時間複雜度的計算我只是給了一個感性的估計方法，若是想要很是精確的計算出來的話，也是須要像建堆時那樣一步一步計算的，只是計算出來的結果也依然是 \(O(n*lgn)\) ，因此爲了偷懶，我就不驗算了嘛，畢竟仍是挺費時的。

註釋

前文咱們提到對於堆這種數據結構，雖然咱們採用數組實現，但在理解時請將其視爲樹，其實在計算機中，全部的內容都是 0-1 串，不管你是儲存了一張圖片，仍是一個word文檔，他們都是 0-1 串，但爲何會有不一樣的呈現方式呢？其實就是對其的解釋不一樣。例如在 Windows 操做系統下，文件具備一個屬性叫作後綴名，當你修改了其後綴名之後，文件內容其實什麼都沒有變化，惟一的變化是對其解釋不一樣了。例如對於一個 html 文件，當你把他解釋爲一個網頁時，可使用瀏覽器打開，效果就是咱們平時所看到的各類網頁，當你把他解釋爲一個文本文件時，就可使用記事本或者其餘編輯器打開，你就能查看他的源代碼。Windows 採用後綴名的方式，一是爲了方便自動選擇合適的軟件打開某個文件（固然，你是能夠在每次打開時手動選擇的，但每次都手動選擇，是真的不適合我這種懶人），二是方便用戶瞭解文件內容，好比當用戶看到一個後綴名爲 png 的文件時，就能知道這大機率是圖片（畢竟不能排除有人故意亂改後綴名），後綴名是 zip 時，能知道這是一個壓縮包。而在 Linux 下，系統選擇打開某個文件的軟件時，只查看文件開頭的一部分字符串（不一樣的文件格式具備不一樣的文件頭，或者被稱爲魔數），據此來判斷文件格式，然後綴名的做用就只有咱們上文所說的第二個做用了。

結語

本文咱們詳細介紹了堆排序的相關內容，若是前面幾篇文章認真看了的話，理解起來也並不困難，若是隻是想要知道堆排序怎麼寫的話，彷佛前面幾篇文章頁不須要看2333，畢竟主要難度仍是在於時間複雜度的計算上。但若是想要深刻理解算法這個巨坑的話，建議打好數學基礎，在時間複雜度的計算上，數學基礎是很重要的。下一篇文章咱們將會介紹快速排序。

原文連接：albertcode.info

我的博客：albertcode.info