堆排序【代碼】

思路參考《算法導論》P84

堆排序中用到的最重要的就是堆這種數據結構，也正是由於這種數據結構能把時間複雜度控制在O(n * lgn)

heapsort算法主要依賴於兩個函數

MAX_HEAPIFY(int *A,int i,int len)

用於維護最大堆，時間複雜度爲O(lgn)，注意書上描述這個函數的算法只用了兩個形參，而因爲C++沒法經過指針獲取數組的大小，因此我額外添加了一個參數做爲數組的大小

BUILD_MAX_HEAP(int *A,int len)

從無序的輸入數據數組中構造一個最大堆，時間複雜度爲O(n)，這裏一樣添加了一個參數

若是用其餘語言好比Java實現，只需把數組名做爲參數穿進來便可，Java支持數組拷貝，支持經過數組名獲取數組大小，比這裏簡單一點

排序算法的詳細過程就不描述了，書上講的挺清楚的

 

----------------------------------------------------------代碼-------------------------------------------------------

  1 // Heapsort.cpp: 定義控制檯應用程序的入口點。
  2 //
  3 
  4 
  5 #include "stdafx.h"
  6 #include <iostream>
  7 
  8 using namespace std;
  9 
 10 int PARENT(int i)
 11 {
 12     return (i - 1) / 2;
 13 }
 14 
 15 int LEFT(int i)
 16 {
 17     return 2 * i + 1;
 18 }
 19 
 20 int RIGHT(int i)
 21 {
 22     return 2 * i + 2;
 23 }
 24 //維護最大堆，時間複雜度爲O(lgn)
 25 int MAX_HEAPIFY(int *A,int i,int len)
 26 {
 27     int l, r, largest;//l爲左孩子的下標，r爲右孩子的下標，largest爲三者中最大數的下標
 28     int temp;
 29     l = LEFT(i);
 30     r = RIGHT(i);
 31     if (l < len && A[l] > A[i])
 32         largest = l;
 33     else
 34         largest = i;
 35 
 36     if (r < len && A[r] > A[largest])
 37         largest = r;
 38     
 39     if (largest != i)
 40     {
 41         temp = A[i];
 42         A[i] = A[largest];
 43         A[largest] = temp;
 44         MAX_HEAPIFY(A, largest, len);
 45     }
 46     else
 47     {
 48         if (l >= len && r >= len)//到達了葉節點，中止遞歸
 49         {
 50             return 0;
 51         }
 52         MAX_HEAPIFY(A, l, len);
 53         MAX_HEAPIFY(A, r, len);
 54     }    
 55 }
 56 
 57 //從無序的輸入數據數組中構造一個最大堆，時間複雜度爲O(n)
 58 int BUILD_MAX_HEAP(int *A,int len)
 59 {
 60     int start = PARENT(len);
 61     for (int i = start; i >= 0; i--)
 62     {
 63         MAX_HEAPIFY(A, i, len);
 64     }
 65     return 0;
 66 }
 67 
 68 int HEAPSORT(int *A,int len)
 69 {
 70     int length = len;
 71     int *res = new int[len]{0};//記錄排完序後的結果
 72     int ptr = len - 1;
 73     BUILD_MAX_HEAP(A, len);
 74 
 75     for (int i = 0; i < length; i++)
 76         cout << A[i] << ends;
 77     cout << endl << endl;
 78 
 79     for (int i = length; i >= 1; i--)
 80     {
 81         res[ptr--] = A[0];
 82         A[0] = A[len-1];
 83         len--;
 84         int *A_temp = new int[len];
 85         for (int i = 0; i < len; i++)//把刪掉最後一個元素後的數組A複製到A_temp中
 86         {
 87             A_temp[i] = A[i];
 88         }
 89         MAX_HEAPIFY(A_temp, 0, len);//對A_temp從新維持爲最大堆
 90         for (int i = 0; i < len; i++)//把A_temp的值複製給A
 91         {
 92             A[i] = A_temp[i];
 93         }
 94 
 95         for (int i = 0; i < len; i++)
 96             cout << A[i] << ends;
 97         cout << endl;
 98         delete A_temp;
 99     }
100 
101     cout << "排序後的數組爲（升序）：" << endl;
102     for (int i = 0; i < length; i++)
103         cout << res[i] << ends;
104     cout << endl;
105     return 0;
106 }
107 
108 int main()
109 {
110     int A[] = {16,4,10,14,7,9,3,2,8,1};
111     cout << "排序前的數組爲：" << endl;
112     for (auto c : A)
113         cout << c << ends;
114     cout << endl;
115     /*BUILD_MAX_HEAP(A,10);
116     for (auto c : A)
117         cout << c << ends;
118     cout << endl;*/
119     HEAPSORT(A,10);
120     return 0;
121 }

運行結果：