堆排序 Java

堆排序主要是理解其基本思想：主要十三个函数的书写 堆化函数 建造最大堆 以及排序函数

堆化主要是对某一个节点调整其左右节点的顺序 根据其大小，但是调整后的节点可能会不符合大顶的特性，所以会继续对与跟节点调换的节点实行同样的规则，（可以递归 可以迭代）。

建造最大堆 是利用堆化函数 从最后一个非叶子节点开始 ，堆化，等遍历到 0 时此时，已经建造成为最大堆。
排序时候 就可以 把最后的元素 与 堆定的元素 互换 。然后继续循环调用 建堆函数来建造最大堆，然后调换堆顶元素与堆尾元素。

我在写这个排序的时候 遇到了 一个问题 就是，你heapSort(int [] a)参数为数组，而你在调用buildMaxHeap()函数的时候，你的每次建堆的size是不一样的，这样就没法通过一直调用a.length来计算待建堆的数组大小，所以我就只能在参数中传入 length参数。这样可以动态的改变length大小。

 public static void MaxHeapify(int a[],int index,int length){

   /*     int max = a[index];
        if(a[index*2+1]>max){
            max = a[2*index+1];
        }
        if(a[index*2+2]>max){
            max = a[index*2+2];
        }*/
        int key = a[index];
       for(int i= index*2+1;i<length;i=i*2+1){

           //选取最大子节点的下标
           if(i+1<length && a[i]<a[i+1]){
               i++;
           }
           if(a[i]>key){
               //将“跟节点”赋值为最大值
               a[index]=a[i];
               index = i;
           }else{
               break;
           }

       }
        a[index] = key;
    }
    public static void buildMaxHeap(int[] a,int length) throws Exception {
        if(length>a.length){
            throw new Exception("ssssssssss");
        }
        for(int i = (length-1)/2;i>=0;i--){
            MaxHeapify(a,i,length);
        }
    }

    public static void heapSort(int[] a) throws Exception {
        for(int i = 0;i<a.length;i++){
            //构建最大堆
            buildMaxHeap(a,a.length-i);
            //
            int tmp=a[0];
            a[0] = a[a.length-i-1];
            a[a.length-i-1] = tmp;

        }

    }

    public static void main(String[] args) throws Exception {
        int[] a={1,3,4,0,2,10,-1,-2,-45};
        heapSort(a);
        for(int data:a){
            System.out.println(data);
        }

    }

下面是 堆化的递归代码

   public static void heapify(int[] a,int index,int length){
       if(index>(length-1)/2){
           return;
       }
       //初始化最大值的索引index
       int max = index;
       int lChild = 2*index+1;
       int rChild = 2*index+2;

       if(lChild<length && a[lChild]>a[max]){
           max = lChild;
       }
       if(rChild<length && a[rChild]>a[max]){
           max = rChild;
       }
       //然后把最大值赋值给 index节点
     if(max!=index){

         int tmp = a[index];
         a[index] = a[max];
         a[max] = tmp;
         heapify(a,max,length);
     }
   }