引言

此文基于《經典數據結構——堆的實現》中堆結構，實現一個以堆處理排序的算法。

一、算法思想

基于堆結構的堆排序的算法思想非常簡單，循環獲取大根堆中的最大值（0位置的根節點）放到堆的末尾，直到將堆拿空。

由于一個現成的大根堆可以實現 O(1) 時間復雜度的最大值返回，因此堆排序的主要時間消耗就是在 heapInsert 或 heapify 這類維護大根堆結構的過程上。

二、代碼演示

首先將數組從0開始，模擬逐個放入的過程，循環 heapInsert 建堆。

然后以整個數組為堆，模擬循環取出 0 位置（最大值）的操作，循環 heapify。

小提示，取出的最大值你可以放在原數組中（即堆尾位置，由于拿出元素會導致堆縮小，數組末尾會有空余位置），也可以新創建一個同長數組放入，這對于排序本身并無影響，只不過是會增加額外的空間復雜度。

public static void heapSort(int[] arr) {if (arr == null || arr.length < 2)return;// 整體變為大根堆for (int i = 0; i < arr.length; i++) {heapInsert(arr, i);}// 以整個數組作為堆大小，假設此堆已滿int heapSize = arr.length;swap(arr, 0, --heapSize);while (heapSize > 0) {swap(arr, 0, --heapSize);heapify(arr, 0, heapSize);}}

模擬入堆的 heapInsert 、和模擬出堆的 heapify：

// heapInsertprivate static void heapInsert(int[] arr, int index) {int father = (index - 1) / 2;while (arr[index] > arr[father]) {swap(arr, index, father);index = father;father = (index - 1) / 2;}}// heapifyprivate static void heapify(int[] arr, int index, int heapSize) {int leftIdx = index * 2 + 1;while (leftIdx < heapSize) {int largest = leftIdx + 1 < heapSize && arr[leftIdx] < arr[leftIdx + 1] ? leftIdx + 1 : leftIdx;largest = arr[index] < arr[largest] ? largest : index;if (index == largest)break;else {swap(arr, index, largest);index = largest;leftIdx = index * 2 + 1;}}}// 交換數組元素private static void swap(int[] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}

完整代碼及對數器：

public class HeapSort {public static void heapSort(int[] arr) {if (arr == null || arr.length < 2)return;// 整體變為大根堆for (int i = 0; i < arr.length; i++) {heapInsert(arr, i);}// 以整個數組作為堆大小，假設此堆已滿int heapSize = arr.length;swap(arr, 0, --heapSize);while (heapSize > 0) {swap(arr, 0, --heapSize);heapify(arr, 0, heapSize);}}private static void heapInsert(int[] arr, int index) {int father = (index - 1) / 2;while (arr[index] > arr[father]) {swap(arr, index, father);index = father;father = (index - 1) / 2;}}/*** 結合了兩個方向的入堆方式** @param arr* @param index* @param heapSize*/private static void heapifyNew(int[] arr, int index, int heapSize) {if (index == 0) {// 向下int left = index * 2 + 1;while (left < heapSize) {int largest = left + 1 < heapSize && arr[left] < arr[left + 1] ? left + 1 : left;largest = arr[index] < arr[largest] ? largest : index;if (largest == index) break;else {swap(arr, index, largest);index = largest;left = index * 2 + 1;}}} else if (index == heapSize - 1) {// 向上int father = (index - 1) / 2;while (arr[index] > arr[father]) {swap(arr, index, father);index = father;father = (index - 1) / 2;}}}private static void heapify(int[] arr, int index, int heapSize) {int leftIdx = index * 2 + 1;while (leftIdx < heapSize) {int largest = leftIdx + 1 < heapSize && arr[leftIdx] < arr[leftIdx + 1] ? leftIdx + 1 : leftIdx;largest = arr[index] < arr[largest] ? largest : index;if (index == largest)break;else {swap(arr, index, largest);index = largest;leftIdx = index * 2 + 1;}}}private static void swap(int[] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}// for testpublic static void comparator(int[] arr) {Arrays.sort(arr);}// for testpublic static int[] generateRandomArray(int maxSize, int maxValue) {int[] arr = new int[(int) ((maxSize + 1) * Math.random())];for (int i = 0; i < arr.length; i++) {arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());}return arr;}// for testpublic static int[] copyArray(int[] arr) {if (arr == null) {return null;}int[] res = new int[arr.length];for (int i = 0; i < arr.length; i++) {res[i] = arr[i];}return res;}// for testpublic static boolean isEqual(int[] arr1, int[] arr2) {if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {return false;}if (arr1 == null && arr2 == null) {return true;}if (arr1.length != arr2.length) {return false;}for (int i = 0; i < arr1.length; i++) {if (arr1[i] != arr2[i]) {return false;}}return true;}// for testpublic static void printArray(int[] arr) {if (arr == null) {return;}for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}System.out.println();}// for testpublic static void main(String[] args) {int testTime = 500000;int maxSize = 100;int maxValue = 100;boolean succeed = true;for (int i = 0; i < testTime; i++) {int[] arr1 = generateRandomArray(maxSize, maxValue);int[] arr2 = copyArray(arr1);heapSort(arr1);comparator(arr2);if (!isEqual(arr1, arr2)) {succeed = false;break;}}System.out.println(succeed ? "Nice!" : "Fucking fucked!");int[] arr = generateRandomArray(maxSize, maxValue);printArray(arr);heapSort(arr);printArray(arr);} }

三、時間復雜度

結論：堆排序的時間復雜度是O(N * logN)。

簡單說明一下各個步驟的大體時間復雜度，詳細推導不做討論。

堆排序突破不了這個復雜度，為什么？這是因為第二步取值調整無法改變O(N* logN)，同時，基于比較的排序方法也沒有比 O(N * logN) 更好的排序了。

首先，heapInsert 的時間復雜度是 O(logN) ，這個不難理解，因為是二叉樹，每次向上比較和交換的次數只與堆的層高有關，而層高又約等于 logN ，因此調整一次的復雜度就是 O(logN)。

而建堆的過程是循環 heapInsert，因此建堆的時間復雜度就是 O(N * logN)。

同樣，heapipfy 的時間復雜度也是 O(logN)，每次下沉也只與層高有關。而循環下沉同樣也是 O(N * logN)。

因此，除去一些常數時間復雜度和倍數項，最終可知堆排序的時間復雜度是 O(N * logN)。

擴展--建堆的兩種方式

上面的代碼以模擬入堆的方式建堆，循環 heapInsert ，時間復雜度是 O(N * logN)。

但是如果使用反向建堆 ，從數組最后一個元素開始，循環 heapify，那么時間復雜度會降 O(N)。

// O(N) for (int i = arr.length - 1; i >= 0; i--) {heapify(arr, i, arr.length); }

首先不考慮復雜度，但看這種建堆方式，就要比 heapInsert 更優，因為 heapify 是指定 i 位置向下沉，由于最后一層元素更多，而這些元素不需要向下沉，因此可以減少很多不必要的操作。那么每一層從下往上越來越少，向下沉的元素也會越來越少。

再來看時間復雜度。

我們從最后一個元素開始，執行 heapify，由于heapify是向下比較向下沉，因此葉子節點只看一眼自身就直接返回了，而堆的葉子節點數量大概是 N/2 數量級，因此，時間消耗公式可以是：

T(N) = (N / 2) * 1 + (N/4) * 2 + (N/8) * 3 + (N/16) * 4 ...?

這個算式如何求解？可以使用數學上常用的 擴倍相減：

2 * T(N) = N + (N / 2) * 2 + (N / 4) * 3 + (N / 8) * 4 ...

最后兩式錯位相減，得到 T(N) = N + N/2 + N/4 + N/8 + N/16.... 等比數列求和，當 N 無限大時，收斂于 O(N)。

?

總結

以上是生活随笔為你收集整理的排序算法 —— 堆排序的全部內容，希望文章能夠幫你解決所遇到的問題。

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