递归排序之堆排序

堆排序的基础构建堆的数据结构是一颗完全二叉树，完全二叉树大概就是所有的数据都是从上到下，从左到右依次插入数据。

堆的特性，大顶堆：父节点大于子节点；小顶堆：父节点小于子节点。

下面给出代码方便分析

#include<stdio.h>

//这个程序需要注意heapify和buildheap的区别
//heapify只保证改变的最大值那一个子树满足堆的性质，
//因为只递归改变索引的那一个子树，另外一个子树则不会取判断
//又可能那个子树就不满足堆的性质
/*
          4
        /    \
       10     3
      /  \   /  \
     5    1 2    8 
    / \
   7   6
当对上述的二叉树的0索引进行heapify后，看下图，左子树满足堆性质，但右子树不满足
只有buildheap这个函数才能满足建堆性质    
          10
        /   \
       5     3
     /  \   /  \
     7   1 2   8 
    / \
   4   6
而heapsort时，heapsort和heapify都可以，因为另外一个子树也满足堆性质，不需再调整
*/


void swap(int arr[],int i,int j)
{
    int temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp;
}

//对于一个堆来说，若假定当前节点为i,则
//父节点索引为 （i-1）/2，左右子节点分别为 c1=2*i+1; c2=2*i+1;
void heapify(int arr[],int n,int i)
{
    if(i>=n)
    {
        return ;
    }
    int c1=2*i+1; 
    int c2=2*i+2;
    int max=i;
    if(c1<n && arr[c1]>arr[i])
    {
        max=c1;
    }
    if(c2<n&& arr[c2]>arr[max])
    {
        max=c2;
    }
    if(max!=i)
    {
        swap(arr,max,i);
        heapify(arr,n,max);
    }
}

void buildheap(int arr[],int n)
{
    int last_node=n-1;
    int parent=(last_node-1)/2;
    int i;
    for(i=parent;i>=0;i--)
    {
        heapify(arr,n,i); //这里的heapify 需要递归，要不可能上层的变动导致子树的堆性质改变
    }
}
void heapsort(int arr[],int n)
{
    int i;
    for(i=n-1;i>=0;i--)
    {
        swap(arr,0,i);
        //heapify(arr,i,0);
        buildheap(arr,i); //这两个都可以，因为此时使用heapify，另外一个子树也满足堆性质 
    }
}
void Print(int A[],int N)
{
    int i;
    for(i=0;i<N;i++)
    {
        printf(" %d ",A[i]);
    }
}
int main()
{
    //const int n=6;
    int arr[9]={4,10,3,5,1,2,8,7,6};
    Print(arr,9);
    printf("\n");
    buildheap(arr,9);
    heapsort(arr,9);
    Print(arr,9);
    printf("\n");
    return 0;
}