堆排序算法

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

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

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

② 再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R
交换，由此得到新的无序区R[1..n-1]和有序区R
，且满足R[1..n-1].keys≤R
.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]调整为堆。

……

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

package com.zhangyao;
public class HeapSort {
public static void main(String[] args) {
int[]s={16,4,10,14,7,9,3,2,8,1};
maxHeapSort(s);
for(int cc=0;cc<s.length;cc++){
System.out.print(s[cc]+" ");
}
}
public static void buildMaxHeap(int a[],int n){    // 建最大堆
for(int i=n/2-1;i>=0;i--){                     // a[n/2...n]都是树中的叶子，因此可以看成只含一个元素的堆
maxHeap(a,i,n);
}
}
public static void maxHeap(int a[],int i,int n ){ // 保持最大堆，时间复杂度为：在高度为h的节点上时间为：O(h)
int left=(i<<1)+1;                            // 左节点
int right=(i<<1)+2 ;                          // 右节点
int largest=0;                                // 存放最大节点的下标
if(left<=n&&a[left]>a[i]){
largest=left;
}else{
largest=i;
}
if(right<=n&&a[right]>a[largest]){
largest=right;
}
if(largest!=i){
int temp=a[i];
a[i]=a[largest];
a[largest]=temp;
maxHeap(a,largest,n);                     // 递归子树，使交换后子树保持最大堆性质
}
}
public static void maxHeapSort(int s[]){
buildMaxHeap(s,s.length-1);                  //    建立最大堆，时间复杂度  O(n)
for(int i=s.length-1;i>0;i--){               //    调换根元素和最后一个节点,n-1调用中每一次时间代价为：O(lg(n))
int tempq=s[i];
s[i]=s[0];
s[0]=tempq;
maxHeap(s,0,i-1);                        //     剔除最后一个节点，使剩下的保持最大堆
}
}
}

结论: 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。