堆是一種特殊的完全二叉樹，其特點是所有父節點都比子節點要小，或者所有父節點都比字節點要大。前一種稱為最小堆，後一種稱為最大堆。

比如下面這兩個：

那麽這個特性有什麽作用？既然題目是堆排序，那麽肯定能用來排序。想要用堆排序首先要創建一個堆，如果對4 3 6 2 7 1 5這七個數字做從小到大排序，需要用這七個數創建一個最大堆，來看代碼：

print?

1. public class HeapSort {
3. private int[] numbers;
4. private int length;
6. public HeapSort(int[] numbers) {
7. this.numbers = numbers;
8. this.length = numbers.length;
9. }
11. /**
12. * 調整二叉樹
13. * 如果父節點編號為x, 那麽左子節點的編號是2x, 右子節點的編號是2x+1
14. * 節點編號從1開始, 對應數組中的索引是編號-1
15. * @param nodeId 節點編號, 從1開始
16. */
17. public void adjust(int nodeId) {
18. int swapId;
19. int flag = 0; //是否需要繼續向下調整
20. while(nodeId * 2 <= this.length && flag == 0) {
21. //首先判斷它和左子節點的關系, 並用swapId記錄值較小的節點編號(最大堆是記錄較大的)
22. int index = nodeId - 1; //節點對應數組中數字的索引
23. int leftChild = nodeId * 2 - 1; //左子節點對應數組中數字的索引
24. int rightChild = nodeId * 2; //右子節點對應數組中數字的索引
25. if(numbers[index] < numbers[leftChild]) {
26. swapId = nodeId * 2;
27. } else {
28. swapId = nodeId;
29. }
30. //如果有右子節點, 再與右子節點比較
31. if(nodeId * 2 + 1 <= this.length) {
32. if(numbers[swapId - 1] < numbers[rightChild])
33. swapId = nodeId * 2 + 1;
34. }
35. //如果最小的節點編號不是自己, 說明子節點中有比父節點更小的
36. if(swapId != nodeId) {
37. swap(swapId, nodeId);
38. nodeId = swapId;
39. } else {
40. flag = 1;
41. }
42. }
43. }
45. /**
46. * 交換兩個節點的值
47. * @param nodeId1
48. * @param nodeId2
49. */
50. public void swap(int nodeId1, int nodeId2) {
51. int t = numbers[nodeId1 - 1];
52. numbers[nodeId1 - 1] = numbers[nodeId2 - 1];
53. numbers[nodeId2 - 1] = t;
54. }
56. /**
57. * 創建最大堆
58. */
59. public void createMaxHeap() {
60. //從最後一個非葉節點到第一個節點依次向上調整
61. for(int i = this.length / 2; i >= 1; i--) {
62. adjust(i);
63. }
64. }
66. public static void main(String[] args) {
67. int[] numbers = new int[] { 4, 3, 6, 2, 7, 1, 5 };
68. for(int x = 0; x < numbers.length; x++) {
69. System.out.print(numbers[x] + " ");
70. }
71. System.out.println();
72. HeapSort heap = new HeapSort(numbers);
73. heap.createMaxHeap();
74. }
75. }

對本例中的數列，從this.length / 2到1，共執行了三輪循環。

第一輪：

第二輪：

第三輪：

調整完成後，當前的二叉樹已經符合最大堆的特性，可以用來從小到大排序。堆排序的原理是，交換堆頂和最後一個節點的數字，即把最大的數字放到數組最後，然後對除了最大數的前n-1個數從新執行調整過程，使其符合最大堆特性。重復以上過程直到堆中只剩下一個數字。

print?

1. public void sort() {
2. while(this.length > 1) {
3. swap(1, this.length);
4. this.length--;
5. adjust(1);
6. }
7. for(int x = 0; x < numbers.length; x++) {
8. System.out.print(numbers[x] + " ");
9. }
10. }

堆排序的時間復雜度和快速排序的平均時間復雜度一樣，是O(nlogn)。

Java與算法之(8) - 堆排序