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

標籤：numbers   https   log   copy   pop   迴圈   api   個數   完全   

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

比如下面這兩個：

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

 

[java] view plain copy  print?

1. public class HeapSort {  
2.   
3.     private int[] numbers;  
4.     private int length;  
5.   
6.     public HeapSort(int[] numbers) {  
7.         this.numbers = numbers;  
8.         this.length = numbers.length;  
9.     }  
10.   
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.     }  
44.   
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.     }  
55.   
56.     /** 
57.      * 建立最大堆 
58.      */  
59.     public void createMaxHeap() {  
60.         //從最後一個非分葉節點到第一個節點依次向上調整  
61.         for(int i = this.length / 2; i >= 1; i--) {  
62.             adjust(i);  
63.         }  
64.     }  
65.   
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個數從新執行調整過程，使其符合最大堆特性。重複以上過程直到堆中只剩下一個數字。

 

[java] view plain copy  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) - 堆排序