堆排序

堆，是一个完全二叉树。
利用数组的下标，从0开始，假设父节点下标是i，那么左孩子下标是2i+1，右孩子下标是2i+2。假设一个节点下标是k,那么父节点下标是(k-1)/2。
从最后一个元素开始建立堆，建立完成之后，堆的首部（第一个元素）就是最小值，然后取出来，将堆的最后一个元素放到堆首部，直至堆中元素的个数为1

import java.util.Arrays;

public class HeapSort {
    /**
     * 建立堆
     * 
     * @param arr表示数组
     * @param n表示堆中元素个数
     * @param k表示待建立堆的元素的下标
     */
    public static void buildHeap(int[] arr, int n, int k) {
        n = n - 1;// 表示堆中最后一个元素的下标
        int k1 = 2 * k + 1, k2 = 2 * k + 2;// 左孩子，右孩子的下标
        if (k1 > n && k2 > n) {
            return;
        }
        // 获取左右孩子中，值较小的节点的下标
        int index = k1;
        if (k1 < n && k2 <= n) {
            if (arr[k1] > arr[k2])
                index = k2;
        }
        if (index <= n) {
            // 假设父节点大于孩子节点，则互换
            if (arr[index] < arr[k]) {
                int temp = arr[index];
                arr[index] = arr[k];
                arr[k] = temp;
            }
        }
        // 从孩子节点往下递归
        if (k1 < n)
            buildHeap(arr, n, k1);
        if (k2 < n)
            buildHeap(arr, n, k2);
    }

    public static void heapSort(int[] arr) {
        //从最后一个元素开始建堆
        for (int i = 0; i < arr.length; i++) {
            buildHeap(arr, arr.length, arr.length - 1 - i);
        }
        for (int i = 0; i < arr.length - 1; i++) {
            int n = arr.length - 1; // 最后一个元素的下标
            //堆中的第一个元素始终是当前堆的最小值，输出，然后将当前堆的最后一个元素放到堆首
            System.out.println(arr[0]);
            //这里将当前堆的最小值，存在当前堆的最后一个位置。当此for结束后，arr就是从大到小排序的
            int temp = arr[0];
            arr[0] = arr[n - i];
            arr[n - i] = temp;
            print(arr);
            System.out.println();
            //因为将当前堆的最后一个元素放到了堆首，所以重新建堆
            if (n - i - 1 > 0)
                buildHeap(arr, n - i, 0);
        }
    }

    static void print(int[] arr) {
        System.out.println(Arrays.toString(arr));
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = { 16, 20, 12, 5, 7, 1, 4, 8, 3, 9 };
        heapSort(arr);
    }
}

建议画图，理解其过程。