2012/3/28----堆排序

堆排序是一种基于二叉树的排序，利用二叉树的性质进行排序的算法。但是这里的二叉树并不是真实存在的，是我们利用数组的编号进行设计的特殊的二叉树。

而堆排序其本质是一个就地排序算法。

Java代码  

1. /*  
2.  * 堆排序算法  
3.  * @version 1.0 2012/3/28  
4.  * @author akon  
5.  */  
6. package com.akon405.www;   
7.   
8. public class HeapSort {   
9.     /*  
10.      * createMaxHeap的功能：  
11.      * 创建最大堆  
12.      */  
13.     public void createMaxHeap(int[] A,int length){   
14.         int j;//最后一个非叶子节点          
15.         for(j=length/2-1;j>=0;j--){   
16.             heapAdjust(A,j,length);//依次遍历每个非叶结点，然后做出调整   
17.         }   
18.     }   
19.     /*  
20.      * heapAdjust的功能：  
21.      * 进行堆的调整，使它始终是最大堆  
22.      */  
23.     public void heapAdjust(int[] A,int i,int length){   
24.         int l,r,temp;   
25.         l=i*2+1;//非叶节点的左子节点   
26.         r=i*2+2;//非叶节点的右子节点   
27.   
28.         int largest=i;//比较当前节点和子节点的大小的标志   
29.            
30.         while(l<length||r<length){   
31.             if(l<length&&r<length){   
32.                 //当左右子节点都存在的时候   
33.                 if(A[i]<A[l]&&A[r]<A[l]){   
34.                     largest=l;   
35.                 }   
36.                 if(A[i]<A[r]&&A[r]>A[l]){   
37.                     largest=r;   
38.                 }   
39.             }else if(l<length&&r>=length){   
40.                 //只有左子节点，没有右子节点   
41.                 if(A[i]<A[l]){   
42.                     largest=l;   
43.                 }   
44.             }   
45.         if(largest!=i){   
46.             temp=A[i];   
47.             A[i]=A[largest];   
48.             A[largest]=temp;   
49.                
50.             i=largest;   
51.             l=i*2+1;   
52.             r=i*2+2;   
53.         }else{   
54.             break;   
55.         }   
56.         }   
57.     }   
58.     /*  
59.      * HeapSort的功能：  
60.      * 进行堆排序  
61.      */  
62.     public  HeapSort(int[] A,int length){   
63.            
64.         int temp;   
65.         createMaxHeap(A,length);//创建最大堆   
66.         System.out.print("最大堆：");   
67.         for(int i=0;i<A.length;i++){   
68.             System.out.print(A[i]+",");//输出我们第一次创建的最大堆（主要是用来调试程序）   
69.             }   
70.         while(length>1){   
71.             temp=A[length-1];   
72.             A[length-1]=A[0];   
73.             A[0]=temp;   
74.             length--; //把最大的数值放到数组末尾，然后再把堆进行整理，让剩余的数值继续构成一个最大堆   
75.             heapAdjust(A,0,length);   
76.         }   
77.         System.out.println("");   
78.         System.out.print("排序结果：");   
79.         for(int i=0;i<A.length;i++)   
80.             System.out.print(A[i]+",");   
81.     }   
82.     /**  
83.      * @param args  
84.      */  
85.     public static void main(String[] args) {   
86.         // TODO Auto-generated method stub   
87.         int[] A={40,10,32,8,78,98,20,3,1};   
88.         int length=A.length;   
89.         new HeapSort(A,length);   
90.     }   
91. }