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个关键字即可以使得文件递增有序。

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

代码实现：

public class HeapSort  { 
    publicstatic void main(String[] args)  
    { 
       int[] a = {26, 5, 77, 1, 61, 11, 59, 15, 48, 19}; 
         
       Sort(a);  
    } 
   ////小堆排序
    publicstatic void Sort(int[] a)  
    { 
       int n = a.length;  
       int temp = 0;  
         
       Display(a, "Before sort : ");  
         
       for(int i=n/2; i>0; i--)  
           Adjust(a, i-1, n);  
         

       for(int i=n-2; i>=0; i--)  
       {  
           temp = a[i+1];  
           a[i+1] = a[0];  
           a[0] = temp;  
             
           Adjust(a, 0, i+1);  
       }  
         
       Display(a, "After  sort : "); 
    } 
     
   public  static void Adjust(int[] a, int i, int n) 
    { 
       int j = 0;  
       int temp = 0;  
         
       temp = a[i];     
       j = 2 * i + 1;  
         
       while(j <= n-1)  
       {  
           if(j < n-1 && a[j]< a[j+1])  
               j++;  
             
           if(temp >= a[j])  
               break;  
             
           a[(j-1)/2] = a[j];  
             
           j = 2 * j + 1;
           Display(a, "----- ");  
       }  
         
       a[(j-1)/2] = temp;  
    } 
     
    publicstatic void Display(int[] a, String str)  
    { 
       System.out.println(str);  
         
       for(int i=0; i<a.length; i++) 
           System.out.print(a[i] + " ");  
         
       System.out.println();  
   } 

计算详细为：

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