堆排序算法

整体思想：

1. 从第一个非叶子节点开始将数组初始化为一个大顶堆
2. 大顶堆上第一个元素为最大元素，即数组0号位元素，将该元素放到数组末位上
3. 重新调整大顶堆
4. 继续将数组0号位元素放到倒数第二位置上

注意：如果是从大到小排序，则应该使用小顶堆。

代码实现重点：

1. 调整大顶堆的函数应该传入三个参数，数组，调整起始点，数组长度。
2. 将起始点的值保留，将其赋给子节点（如果子节点大于父节点）
3. 定义指针k指向该节点的左子节点以及左孙子节点等，如果右子节点大于左子节点，则指向右子节点
4. 如果子节点的值大于初始节点的值，则将子节点的值赋给父节点
5. 此外，需要为初始节点的值找位置，所以将i指针指向替换父节点的子节点。

import java.util.Arrays;

public class HeapSort {

    private static void heapSort(int[] arr){

        //从第一个非叶子节点开始将数组初始化为一个大顶堆
        for(int i=arr.length/2-1;i>=0;i--){
            adjustHeap(arr,i,arr.length);
        }

        //初始化后，堆定元素最大，将堆定元素放到数组最后
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);
            //只是改变了一个值，所以只需要走一次堆排序
            adjustHeap(arr,0,j);
        }
    }

    private static void adjustHeap(int[] arr,int i,int len){

        //保存起始元素值
        int temp=arr[i];
        //i指向父节点，k指向较大子节点
        for(int k=i*2+1;k<len;k=k*2+1){

            if(k+1<len&&arr[k]<arr[k+1]){
                k++;
            }
            //如果子节点值大于初始i节点的值，将子节点值赋给父节点，i指向子节点索引
            if(arr[k]>temp){
                arr[i]=arr[k];
                i=k;
            }else{
                break;
            }
        }

        //将起始值放入到i最后指向的子节点上
        arr[i]=temp;
    }

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

    public static void main(String[] args) {
        int[] arr=new int[]{9,8,7,6,5,4,3,2,1};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

 引自https://www.cnblogs.com/chengxiao/p/6129630.html