堆排序

最大堆排序算法：

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

#define LEFT(i) i*2+1
#define RIGHT(i) i*2+2
#define PARENT(i) floor((i-1)/2)

typedef int DataType;
/*
   局部特性：对节点i，考察它的子树，将其子树下面的最大值换到该节点上来。
*/
void max_heapify(DataType A[],int i,int length)
{
    int l,r;
    int large;
    l = LEFT(i);
    r = RIGHT(i);
    if( (l < length) && (A[l] > A[i])){
        large = l;
    }else{
        large = i;
    }

    if( (r < length) && (A[r] > A[large])){
        large = r;
    }
    if(large != i){
        DataType tmp;
        tmp = A[i];
        A[i] = A[large];
        A[large] = tmp;
        max_heapify(A,large,length);
    }


}
/*
构建大堆结构，对于叶子节点，无需进行调整，所以只需调整中间节点。而中间节点的范围是再0-PATENT(length)直接。
*/
void build_max_heap(DataType A[],int length)
{
    int i;
    for(i=PARENT(length);i>=0;i--){
        max_heapify(A,i,length);
    }
}
/*
堆排序，由于0元素再建堆之后，肯定是最大的。所以将其摘到数组最后，将叶子调到堆中。然后对0元素做堆出来，找到最大的那个，再摘到数组中
这样循环，直到堆中的最后一个元素。这里可以看出来，其实这样做的冗余度挺大的。因为如果堆高度很高，而每一次摘除之后，找到最大的那个元素
需要做很多递归调用。因为需要改进尽快找到那个最大的元素。
*/
void heapsnort(DataType A[],int length)
{
    int i;
    build_max_heap(A,length);
    for(i=length-1;i>0;i--){
        DataType tmp;
        tmp = A[0];
        A[0] = A[i];
        A[i] = tmp;
        max_heapify(A,0,i);
    }
}
int main()
{
    int i;
    int length;
    DataType A[10]={4,1,3,2,16,9,10,14,8,7};
    printf("sizeof = %d\n",sizeof(A)/sizeof(DataType));
    length = sizeof(A)/sizeof(DataType);
    //max_heapify(A,1,length);
    //build_max_heap(A,length);
    heapsnort(A,length);
    for(i=0;i<10;i++){
        printf("%d ",A[i]);
    }
    printf("\n");
    return 0;
}