第6章 堆排序 java实现 最简版

 1 public class Heap {
 2     
 3     public int heap_size;//在build_max_heap中初始化，由heap_sort自动调用
 4     
 5     public int parent(int i){
 6         return (i - 1) / 2;
 7     }
 8     public int left(int i){
 9         return 2 * i + 1;
10     }
11     public int right(int i){
12         return 2 * i + 2;
13     }
14     
15     /** 保持堆的性质,
16      * 假定left(i), right(i)为根的两根二叉树都是最大堆，
17      * A[i]可能小于其子女，这样就违背了最大堆性质
18      * 该函数让A[i]在最大堆中“下降”，使以i为根的子树成为最大堆
19      * */
20     public void max_heapify(int[] A, int i){
21         int l = left(i);
22         int r = right(i);
23         int largest;
24         // 从A[i] A[left(i)] A[right(i)] 中找出最大，下标存在largest中
25         // 若A[i]为最大，则根据假设，i为根的子树已是最大堆，函数结束
26         // 否则交换A[i]和A[largest],交换后下标为largest的节点值为A[i]
27         // 该节点的子树可能违反最大堆,因此对largest下标递归调用
28         if(l < heap_size && A[l] > A[i]){
29             largest = l;
30         } 
31         else{
32             largest = i;
33         }    
34         if(r < heap_size && A[r] > A[largest]){
35             largest = r;
36         }
37         if(largest != i){
38             int tmp = A[i];
39             A[i] = A[largest];
40             A[largest] = tmp;
41             
42             max_heapify(A, largest);
43         }
44     }
45     
46     /**
47      * 建堆
48      * 自底向上将数组A[1..n]（此处n=length[A]）变成最大堆
49      * 子数组A[(floor(n / 2) + 1) .. n]中的元素都是树中的叶子
50      * 所以对每一个非叶子节点都调用一次该过程
51      * */
52     public void build_max_heap(int[] A){
53         heap_size = A.length; // 初始化heap_size
54         for(int i = (heap_size/2 - 1); i > -1; --i){
55             max_heapify(A, i);
56         }
57     }
58     
59     /**
60      * 堆排序算法
61      * 先建造最大堆，根A[1]即为最大，则置换到数组的正确位置A[n]
62      * 从堆中去掉节点n，A[1..n-1]建成最大堆，但新根可能违背了最大堆性质，
63      * 此时调用max_heapify(A,1)可以保持该性质，在A[1..n-1]构造出最大堆。
64      * 不断重复，堆大小从n-1降到2
65      * */
66     public void heapsort(int[] A){
67         build_max_heap(A);
68         for(int i = A.length-1; i > 0; --i){
69             int tmp = A[0];
70             A[0] = A[i];
71             A[i] = tmp;
72             --heap_size;
73             max_heapify(A, 0);
74         }
75     }
76     
77     public static void show_array(int[] A){
78         for(int i = 0; i < A.length; ++i){
79             System.out.print(A[i] + ". ");
80         }
81         System.out.println();
82     }
83     
84     public static void main(String[] args){
85         int[] A = {4, 1, 3, 2, 16, 9, 10, 14, 8, 7};
86         
87         
88         System.out.println("before heapsort：");
89         show_array(A);
90         
91         Heap h = new Heap();
92         h.heapsort(A);
93         
94         System.out.println("after heapsort：");
95         show_array(A);
96         
97     }
98     
99 }