内部排序（五）堆排序算法

#include<stdio.h>
#include<stdlib.h>

#define MAXSIZE 20
#define N 8


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


typedef int KeyType;
typedef int InfoType;



struct RedType
{
 KeyType key;
 InfoType otherinfo;
};
struct Sqlist
{
 RedType r[MAXSIZE+1];//r[0]闲置或作哨兵单元
 int length;
};

typedef Sqlist HeapType;

void HeapAdjust(HeapType &H,int s,int m)
{
  RedType rc;  
  int j;
  rc = H.r[s];
  for(j = 2*s;j<=m;j*=2)
  {
	  if(j<m && LT(H.r[j].key,H.r[j+1].key)) ++j;
	  if( !LT(rc.key,H.r[j].key) ) break;
	  H.r[s] = H.r[j];
	  s = j;
  }
   H.r[s] = rc;
}

void HeapSort(HeapType &H)
{
  RedType t;
  int i;
   for (i=H.length/2; i>0; --i) 
     HeapAdjust ( H, i, H.length );
   for (i=H.length; i>1; --i)
   {
         t=H.r[1];
         H.r[1]=H.r[i];
         H.r[i]=t; 
         HeapAdjust(H, 1, i-1); 
   }
}

void print(HeapType H)
{
  int i;
  for(i=1;i<=H.length;i++)
     printf("(%d,%d)",H.r[i].key,H.r[i].otherinfo);
  printf("\n");
}

int main()
{
	RedType d[N] ={ {49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8} };
    HeapType h;
	int i;
    for(i=0;i<N;i++)
       h.r[i+1] = d[i];
    h.length = N;
	printf("排序前：\n");
    print(h);
	HeapSort(h);
	printf("排序后：\n");
	print(h);
    return 0;
}

堆这个东西确实很巧妙：

1.我们先从一个无序序列创建一个堆。

2.在输出堆顶元素后，我们用最后一个元素取代之，由于根的左右子树均为堆，则仅需自上至下进行调整即可。

从一个无序序列建堆的过程就是一个反复筛选的过程。若将此序列看成一个完全二叉树（这一点巧妙利用完全二叉树的性质），则最后一个非终端结点是第floor(n/2)（向下取整）个元素,由此，筛选只需从第floor(n/2)个元素开始。

堆 排序其实是两个过程。

第 一个过程是建立堆，第二个过程是从堆顶一个个的输出元素。

如 果我们对一个数组进行从小到大排序。那我们先要建立一个最大堆（完全二叉树非终端结点的值均不小于其左右孩子结点的值），

然后把堆顶元素与最后一个元素的值相交换。把最后一个元素的值置于堆顶。然后再重新建立堆。

这 样一来，当我们从第1个元素开始输出时，得到的就是一个从小到大的序列。

堆 排序仅需要一个用于交换变量的辅助空间。因此其空间复杂度仅为O（1）。

最大堆的创建，其实就是从下到上，把最下面的最大的先移到它的上一层，而把上层的那个被交换下来的较小的元素一直往下移，一直移到它下面的元素都比它小的位置。

这 样移位，就可以保证上层元素一定比下层的要大。移上去的，一定是它和它下面的元素中最大的。这样一样，就可以创建一个最大堆。

这里把一个一维数组的存储结构看成是一个完全二叉树。利用完全二叉树的性质，可以直接找到开始比较的位置在floor(n/2)上。而且可以找到它的孩子结点。这种方式非常的巧妙，思想很值得回味。