个人热身程序(二.堆排序)

#include <stdio.h>
#define LENGTH(a) (sizeof(a)/sizeof(a[0])) //计算数组大小
int main(int argc,char *args[])
{
        int target[]={6,8,4,9,6,3,10};
        void printarray(int length,int keys[]);
        printf("before adopt max heap:/n");
        printarray(LENGTH(target),target);
        void adopt_max_heap(int target[],int i,int length);
        void built_max_heap(int target[],int length);
        void max_heap_sort(int target[],int length);
//      adopt_max_heap(target,2,LENGTH(target));
        //built_max_heap(target,LENGTH(target));
        
        max_heap_sort(target,LENGTH(target));
        printf("/nafer adopt max heap:/n");
        printarray(LENGTH(target),target);
        printf("/n");
}
//输出数组的值
void printarray(int length,int keys[])
{
        int i=0;
        for(;i<length-1;i++)
     {
                printf("%d,",keys[i]);
        }
        printf("%d",keys[i]);
}
//保持大顶堆的属性
void adopt_max_heap(int target[],int i,int length)
{
        int leftchild;
        int rightchild;
        int max;
        if(i>length)
        {
                return;
        }
        else
        {
                max=target[i-1];
                if(2*i-1<length)
                {
                        leftchild=target[2*i-1];
                        if(2*i<length)
                        {
                                rightchild=target[2*i];
         if(leftchild>max&&leftchild>=rightchild)
                                {
                                        leftchild+=target[i-1];
                                        target[i-1]=leftchild-target[i-1];
                                        leftchild=leftchild-target[i-1];
                                        target[2*i-1]=leftchild;
                                        adopt_max_heap(target,2*i,length);
                                }else if(rightchild>max&&rightchild>=leftchild)
                                {
                                        rightchild+=target[i-1];
                                        target[i-1]=rightchild-target[i-1];
                                        rightchild=rightchild-target[i-1];
                                        target[2*i]=rightchild;
                                        adopt_max_heap(target,2*i+1,length);
                                }
                        }
                        else if(leftchild>max)
                        {
                                leftchild+=target[i-1];
                                target[i-1]=leftchild-target[i-1];
                                leftchild=leftchild-target[i-1];
                                target[2*i-1]=leftchild;
                        }
          }
                        
        }
}
//构建大顶堆
void built_max_heap(int target[],int length)
{
        int i=length/2;
        while(i>0)
        {
                adopt_max_heap(target,i,length);
                i--;
        }
}
//大顶堆排序
void max_heap_sort(int target[],int length)
{
        while(length>1)
        {
                
                built_max_heap(target,length);
                target[length-1]+=target[0];
                target[0]=target[length-1]-target[0];
                target[length-1]=target[length-1]-target[0];
                length--;
  }
}

}