4.堆排序：（大根堆）

　　①將存放在array[0，...，n-1]中的n個元素建成初始堆；

　　②將堆頂元素與堆底元素進行交換，則序列的最大值即已放到正確的位置；

　　③但此時堆被破壞，將堆頂元素向下調整使其繼續保持大根堆的性質，再重復第②③步，直到堆中僅剩下一個元素為止。

堆排序算法的性能分析：

　　空間復雜度:o(1)；

　　時間復雜度:建堆：o(n)，每次調整o(log n)，故最好、最壞、平均情況下：o(n*logn);

　　穩定性：不穩定

 1 public class HeapSort {
 2 
 3     public static void main(String[] args) {
 
 4         // TODO Auto-generated method stub
 5         int[] arr={5,54,12,78,45,9,82,62,55,8,0,6,-8,101};
 6         HeapSort p=new HeapSort();
 7         p.heapsort(arr);
 8         for(int i=0;i<arr.length;i++){
 9             System.out.print(arr[i]+" ");
10         }
11     }
12     /*循環建立最大堆，實現排序
 
*/
13     public void heapsort(int[] arr){
14         for(int i=0;i<arr.length-1;i++){
15             buildMaxHeap(arr,arr.length-i-1);
16             swap(arr,0,arr.length-1-i);
17         }
18     }
19     /*建立最大堆*/
20     public void buildMaxHeap(int[] arr,int lastindex){
21         if(arr==null||arr.length<1){
 
22             return;
23         }else{
24             int half=(lastindex-1)/2;
25             for(int i=half;i>=0;i--){
26                 int root=i;
27                 while(2*root+1<lastindex){
28                     int left=2*root+1;
29                     if(left+1<lastindex&&arr[left]<arr[left+1]){
30                         left++;
31                     }
32                     if(arr[root]<arr[left]){
33                         swap(arr,root,left);
34                         root=left;
35                     }else{
36                         break;
37                     }
38                 }        
39             }
40         }
41     }
42     /*交換位置*/
43     public void swap(int[] arr,int i,int j){
44         int temp=arr[i];
45         arr[i]=arr[j];
46         arr[j]=temp;
47     }
48 }

堆排序