内部排序->选择排序->堆排序

文字描述

　　堆排序中,待排序数据同样可以用完全二叉树表示, 完全二叉树的所有非终端结点的值均不大于(或小于)其左、右孩子结点的值。由此，若序列{k1, k2, …, kn}是堆，则堆顶元素(或完全二叉树的根)必为序列中n个元素的最小值(或最大值)。

　　若在输出堆顶的最小值之后，使得剩余n-1个元素的序列重又建成一个堆，则得到n个元素中的次小值。如此反复执行，便能得到一个有序序列，这个过程称之为堆排序。

　　由此，实现堆排序需要解决两个问题：(1)如何由一个无序序列建成一个堆？(2)如何在输出堆顶元素之后，调整剩余元素成为一个新的堆？

　　先讨论第(2)个问题，假设有个最大堆(堆顶元素为堆的最大值)输出堆顶元素之后， 以堆中最后一个元素代替之，此时根结点的左、右子树均为堆，则仅需自上至下进行调整即可。称这个自堆顶至叶子的调整过程为“筛选”。

再讨论第(1)个问题，由一个无序序列建成堆的过程就是一个反复”筛选”的过程。若将此序列看成一个完全二叉树，则最后一个非终端结点是第[n/2]个元素，由此“筛选”只需从第[n/2]个元素开始。

示意图

算法分析

　　堆排序在树形选择排序上进行了改进, 和树形选择排序比, 堆排序可以减少辅助空间, 避免和”最大值”的冗余比较等优点.

　　堆排序在最坏情况下，其时间复杂度也为nlogn。相对于快速排序来说，这是堆排序的最大优点(快速排序最坏情况下时间复杂度为n*n, 但平均性能为nlogn)。

　　堆排序只需一个记录大小的辅助空间供交换用。

　　堆排序是一种不稳定的排序方法。

　　另外，堆排序方法对记录数较少的文件并不提倡使用， 但是对n较大的文件还是很有效的，因为其运行时间主要耗费在建立初始堆和调整新堆时的反复“筛选”上。

代码实现

 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 /*
  * double log2(double x);    以2为底的对数
  * double ceil(double x);    取上整
  * double floor(double x);    取下整
  * double fabs(double x);    取绝对值
  */

 #define DEBUG

 #define EQ(a, b) ((a) == (b))
 #define LT(a, b) ((a) <  (b))
 #define LQ(a, b) ((a) <= (b))

 #define MAXSIZE  100
 #define INF         1000000
 typedef int KeyType;
 typedef char InfoType;
 typedef struct{
     KeyType key;
     InfoType otherinfo;
 }RedType;

 typedef struct{
     RedType r[MAXSIZE+];
     int length;
 }SqList;

 void PrintList(SqList L){
     int i = ;
     printf("下标值：");
     for(i=; i<=L.length; i++){
         printf("[%d] ", i);
     }
     printf("\n关键字：");
     for(i=; i<=L.length; i++){
         if(EQ(L.r[i].key, INF)){
             printf(" %-3c", '-');
         }else{
             printf(" %-3d", L.r[i].key);
         }
     }
     printf("\n其他值：");
     for(i=; i<=L.length; i++){
         printf(" %-3c", L.r[i].otherinfo);
     }
     printf("\n\n");
     return ;
 }

 //堆采用顺序存储表示
 typedef SqList HeapType;

 /*
  *已知H->r[s,...,m]中记录的关键字除H->r[s].key之外均满足的定义
  *本汉书调整H-r[s]的关键字，使H->r[s,...,m]成为一个大顶堆(对其中
  *记录的关键字而言)
  */
 void HeapAdjust(HeapType *H, int s, int m)
 {
     RedType rc = H->r[s];
     int j = ;
     //沿key较大的孩子结点向下筛选
     for(j=*s; j<=m; j*=){
         //j为key较大的纪录的下标
         if(j<m && LT(H->r[j].key, H->r[j+].key))
             j+=;
         //rc应该插入位置s上
         if(!LT(rc.key, H->r[j].key))
             break;
         H->r[s] = H->r[j];
         s = j;
     }
     //插入
     H->r[s] = rc;
 }

 /*
  * 对顺序表H进行堆排序
  */
 void HeapSort(HeapType *H)
 {
     int i = ;
     //把H->r[1,...,H->length]建成大顶堆
     for(i=H->length/; i>=; i--){
         HeapAdjust(H, i, H->length);
     }
 #ifdef DEBUG
     printf("由一个无序序列建成一个初始大顶堆：\n");
     PrintList(*H);
 #endif
     RedType tmp;
     for(i=H->length; i>; i--){
         //将堆顶记录和当前未经排序子序列H->r[1,...,i]中最后一个记录相互交换
         tmp = H->r[];
         H->r[] = H->r[i];
         H->r[i] = tmp;
         //将H->r[1,...,i-1]重新调整为大顶堆
         HeapAdjust(H, , i-);
 #ifdef DEBUG
         printf("调整1至%d的元素，使其成为大顶堆：\n", i-);
         PrintList(*H);
 #endif
     }
 }

 int  main(int argc, char *argv[])
 {
     if(argc < ){
         return -;
     }
     HeapType H;
     int i = ;
     for(i=; i<argc; i++){
         if(i>MAXSIZE)
             break;
         H.r[i].key = atoi(argv[i]);
         H.r[i].otherinfo = 'a'+i-;
     }
     H.length = (i-);
     H.r[].key = ;
     H.r[].otherinfo = '';
     printf("输入数据:\n");
     PrintList(H);
     //对顺序表H作堆排序
     HeapSort(&H);
     return ;
 }

堆排序

运行