基本思想

堆排序是一種樹形選擇排序，是對直接選擇排序的改進。

首先，我們來看看什麼是堆（heap）：

（1）堆中某個節點的值總是不大於或不小於其父節點的值；

（2）堆總是一棵完全二叉樹（Complete Binary Tree）。

 完全二叉樹是由滿二叉樹（Full Binary Tree）而引出來的。除最後一層無任何子節點外，每一層上的所有結點都有兩個子結點的二叉樹稱為滿二叉樹。

如果除最後一層外，每一層上的節點數均達到最大值；在最後一層上只缺少右邊的若干結點，這樣的二叉樹被稱為完全二叉樹。

一棵完全二叉樹，如果某個節點的值總是不小於其父節點的值，則根節點的關鍵字是所有節點關鍵字中最小的，稱為小根堆（小頂堆）

；如果某個節點的值總是不大於其父節點的值，則根節點的關鍵字是所有節點關鍵字中最大的，稱為大根堆（大頂堆）。

從根節點開始，按照每層從左到右的順序對堆的節點進行編號：

可以發現，如果某個節點的編號為i，則它的子節點的編號分別為：2i、2i+1。據此，推出堆的數學定義：

具有n個元素的序列（k₁,k₂,...,k_n)，當且僅當滿足

時稱之為堆。

需要注意的是，堆只對父子節點做了約束，並沒有對兄弟節點做任何約束，左子節點與右子節點沒有必然的大小關係。

如果用陣列儲存堆中的資料，邏輯結構與儲存結構如下：

初始時把要排序的n個數看作是一棵順序儲存的完全二叉樹，調整它們的儲存順序，使之成為一個堆，將堆頂元素輸出，得到n 個元素中最小（最大）的元素，這時堆的根節點的數最小（或者最大）。然後對前面(n-1)個元素重新調整使之成為堆，輸出堆頂元素，得到n 個元素中次小(或次大)的元素。依次類推，直到只有兩個節點的堆，並對它們作交換，最後得到有n個節點的有序序列。這個過程就稱為堆排序

。

寫程式碼之前，我們要解決一個問題：如何將一個不是堆的完全二叉樹調整為堆。

例如我們要將這樣一個無序序列：

49，38，65，97，76，13，27，49

建成堆，將它直接對映成二叉樹，結果如下圖的(a)：

(a)是一個完全二叉樹，但不是堆。我們將它調整為小頂堆。

堆有一個性質是：堆的每個子樹也是堆。

調整的核心思想就是讓樹的每棵子樹都成為堆，以某節點與它的左子節點、右子節點為操作單位，將三者中最小的元素置於子樹的根上。

(a)中最後一個元素是49，在樹中的序號為8，對應的陣列下標則為7，它的父節點對應的陣列下標為3（如果一個元素對應的儲存陣列的下標為i，則它的父節點對應的儲存陣列的下標為(i-1)/2），49小於97，所以兩者交換位置。

此時，以第三層元素為根節點的所有子樹都已是堆了，下一步繼續調整以第二層元素為根節點的子樹。

先調整以65為根的子樹，再調整以38為根的子樹（滿足堆的要求，實際上不用調整）。

然後調整以第一層元素為根的子樹，即以49為根，以38為左子節點，以13為右子節點的子樹，交換13與49的位置。

一旦交換位置，就有可能影響本來已經是堆的子樹。13與49交換位置之後，破壞了右子樹，將焦點轉移到49上面來，繼續調整以它為根節點的子樹。如果此次調整又影響了下一層的子樹，繼續調整，直至葉子節點。

以上就是由陣列建堆的過程。

堆建好之後開始排序，堆頂就是最小值，取出放入陣列中的最後一個位置，將堆底（陣列中的最後一個元素）放入堆頂。這一操作會破壞堆，需要將前n-1個元素調整成堆。

然後再取出堆頂，放入陣列的倒數第二個位置，堆底（陣列中的倒數第二個元素）放入堆頂，再將前n-2個元素調整成堆。

按照上面的思路迴圈操作，最終就會將陣列中的元素按降序的順序排列完畢。

如果想要升序排列，利用大頂堆進行類似的操作即可。下面的java實現就是使用大頂堆完成的。

java實現

//堆排序
      public void heapSort(){
            
             buildHeap();
             System.out.println("建堆：");
             printTree(array.length);
            
             int lastIndex = array.length-1;
             while(lastIndex>0){
                    swap(0,lastIndex);  //取出堆頂元素，將堆底放入堆頂。其實就是交換下標為0與lastIndex的資料
                    if(--lastIndex == 0) break;  //只有一個元素時就不用調整堆了，排序結束
                    adjustHeap(0,lastIndex);  //調整堆
                   
                    System.out.println("調整堆：");
                    printTree(lastIndex+1);
             }
            
      }
     
      /**
       * 用陣列中的元素建堆
       */
      private void buildHeap(){
             int lastIndex = array.length-1;
             for(inti= (lastIndex-1)/2;i>=0;i--){ //(lastIndex-1)/2就是最後一個元素的根節點的下標，依次調整每棵子樹
                    adjustHeap(i,lastIndex);  //調整以下標i的元素為根的子樹                  
             }
      }
     
      /**
       * 調整以下標是rootIndex的元素為根的子樹
       *@param rootIndex 根的下標
       *@param lastIndex 堆中最後一個元素的下標
       */
      private void adjustHeap(int rootIndex,intlastIndex){
            
             int biggerIndex = rootIndex; 
             int leftChildIndex = 2*rootIndex+1;
             int rightChildIndex = 2*rootIndex+2;
            
             if(rightChildIndex<=lastIndex){  //存在右子節點，則必存在左子節點
                   
                    if(array[rootIndex]<array[leftChildIndex] || array[rootIndex]<array[rightChildIndex]){ //子節點中存在比根更大的元素
                     biggerIndex = array[leftChildIndex]<array[rightChildIndex] ? rightChildIndex :leftChildIndex; 
                    }
                   
             }else if(leftChildIndex<=lastIndex){  //只存在左子節點
                   
                    if(array[leftChildIndex]>array[rootIndex]){  //左子節點更大
                           biggerIndex = leftChildIndex;
                    }
             }
            
             if(biggerIndex != rootIndex){  //找到了比根更大的子節點
                   
                    swap(rootIndex,biggerIndex);
                   
                    //交換位置後可能會破壞子樹，將焦點轉向交換了位置的子節點，調整以它為根的子樹
                    adjustHeap(biggerIndex,lastIndex);
             }
      }
     
      /**
       * 將陣列按照完全二叉樹的形式打印出來
       */
      private void printTree(int len){
 
             int layers = (int)Math.floor(Math.log((double)len)/Math.log((double)2))+1;  //樹的層數
             int maxWidth = (int)Math.pow(2,layers)-1;  //樹的最大寬度
             int endSpacing = maxWidth;
             int spacing;
             int numberOfThisLayer;
             for(int i=1;i<=layers;i++){  //從第一層開始，逐層列印
                    endSpacing = endSpacing/2;  //每層列印之前需要列印的空格數
                    spacing = 2*endSpacing+1;  //元素之間應該列印的空格數
                    numberOfThisLayer = (int)Math.pow(2, i-1);  //該層要列印的元素總數
                   
                    int j;
                    for(j=0;j<endSpacing;j++){
                           System.out.print("  ");
                    }
                   
                    int beginIndex = (int)Math.pow(2,i-1)-1;  //該層第一個元素對應的陣列下標
                    for(j=1;j<=numberOfThisLayer;j++){
                           System.out.print(array[beginIndex++]+"");
                           for(intk=0;k<spacing;k++){  //列印元素之間的空格
                                  System.out.print("  ");
                           }
                           if(beginIndex == len){  //已列印到最後一個元素
                                  break;
                           }
                    }
                   
                    System.out.println();
             }
             System.out.println(); 
      }

用以下程式碼測試：

             int [] a = {7,1,9,2,5,10,6,4,3,8};
             Sort sort = new Sort(a);
            
             System.out.println("未排序時：");
             sort.display();
             System.out.println();
            
             sort.heapSort();
             System.out.println("排序完成：");
             sort.display();

列印結果如下：

演算法分析

它的執行時間主要是消耗在初始構建堆和在重建堆時的反覆篩選上。

在構建堆的過程中，因為我們是完全二叉樹從最下層最右邊的非終端結點開始構建，將它與其孩子進行比較和若有必要的互換，對於每個非終端結點來說，其實最多進行兩次比較和互換操作，因此整個構建堆的時間複雜度為O(n)。

在正式排序時，第i次取堆頂記錄重建堆需要用O(logi)的時間（完全二叉樹的某個結點到根結點的距離為log₂i＋1），並且需要取n-1次堆頂記錄，因此，重建堆的時間複雜度為O(nlogn)。

所以總體來說，堆排序的時間複雜度為O(nlogn)。由於堆排序對原始記錄的排序狀態並不敏感，因此它無論是最好、最壞和平均時間複雜度均為O(nlogn)。這在效能上顯然要遠遠好過於冒泡、簡單選擇、直接插入的O(n²)的時間複雜度了。

空間複雜度上，它只有一個用來交換的暫存單元，也非常的不錯。不過由於記錄的比較與交換是跳躍式進行，因此堆排序是一種不穩定的排序方法。