Java排序算法 堆排序

1991年计算机先驱奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德(RobertW．Floyd)和威廉姆斯(J．Williams)在1964年共同发明了著名的堆排序算法( Heap Sort)。本文主要介绍堆排序用Java来实现。

AD：

堆积排序(Heapsort)是指利用堆积树（堆）这种资料结构所设计的一种排序算法，可以利用数组的特点快速定位指定索引的元素。堆排序是不稳定的排序方法，辅助空间为O(1)，最坏时间复杂度为O(nlog2n) ，堆排序的堆序的平均性能较接近于最坏性能。 

堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征，使得在当前无序区中选取最大(或最小)关键字的记录变得简单。

（1）用大根堆排序的基本思想

① 先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区

②再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key

③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。

……

直到无序区只有一个元素为止。

（2）大根堆排序算法的基本操作： 

① 初始化操作：将R[1..n]构造为初始堆；

②每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换，然后将新的无序区调整为堆(亦称重建堆)。

注意： 

①只需做n-1趟排序，选出较大的n-1个关键字即可以使得文件递增有序。

②用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。堆排序和直接选择排序相反：在任何时刻堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止。

代码实现：

[java] view plain copy

1. public class HeapSort  {   
2.     publicstatic void main(String[] args)    
3.     {   
4.        int[] a = {26, 5, 77, 1, 61, 11, 59, 15, 48, 19};   
5.            
6.        Sort(a);    
7.     }   
8.    ////小堆排序  
9.     publicstatic void Sort(int[] a)    
10.     {   
11.        int n = a.length;    
12.        int temp = 0;    
13.            
14.        Display(a, "Before sort : ");    
15.            
16.        for(int i=n/2; i>0; i--)    
17.            Adjust(a, i-1, n);    
18.            
19.   
20.        for(int i=n-2; i>=0; i--)    
21.        {    
22.            temp = a[i+1];    
23.            a[i+1] = a[0];    
24.            a[0] = temp;    
25.                
26.            Adjust(a, 0, i+1);    
27.        }    
28.            
29.        Display(a, "After  sort : ");   
30.     }   
31.        
32.    public  static void Adjust(int[] a, int i, int n)   
33.     {   
34.        int j = 0;    
35.        int temp = 0;    
36.            
37.        temp = a[i];       
38.        j = 2 * i + 1;    
39.            
40.        while(j <= n-1)    
41.        {    
42.            if(j < n-1 && a[j]< a[j+1])    
43.                j++;    
44.                
45.            if(temp >= a[j])    
46.                break;    
47.                
48.            a[(j-1)/2] = a[j];    
49.                
50.            j = 2 * j + 1;  
51.            Display(a, "----- ");    
52.        }    
53.            
54.        a[(j-1)/2] = temp;    
55.     }   
56.        
57.     publicstatic void Display(int[] a, String str)    
58.     {   
59.        System.out.println(str);    
60.            
61.        for(int i=0; i<a.length; i++)   
62.            System.out.print(a[i] + " ");    
63.            
64.        System.out.println();    
65.    }   

计算详细为：

Before sort :
26 5 77 1 61 11 59 15 48 19
-----
26 5 77 48 61 11 59 15 48 19
-----
26 61 77 48 61 11 59 15 1 19
-----
26 61 77 48 19 11 59 15 1 19
-----
77 61 77 48 19 11 59 15 1 5
-----
77 61 59 48 19 11 59 15 1 5
-----
61 61 59 48 19 11 26 15 1 77
-----
61 48 59 48 19 11 26 15 1 77
-----
61 48 59 15 19 11 26 15 1 77
-----
59 48 59 15 19 11 26 5 61 77
-----
59 48 26 15 19 11 26 5 61 77
-----
48 48 26 15 19 11 1 59 61 77
-----
48 19 26 15 19 11 1 59 61 77
-----
26 19 26 15 5 11 48 59 61 77
-----
26 19 11 15 5 11 48 59 61 77
-----
19 19 11 15 5 26 48 59 61 77
-----
19 15 11 15 5 26 48 59 61 77
-----
15 15 11 1 19 26 48 59 61 77
-----
11 5 11 15 19 26 48 59 61 77
-----
5 5 11 15 19 26 48 59 61 77
After 

sort :
1 5 11 15 19 26 48 59 61 77