堆排序

下标从0开始，建堆（向下调整），采用递归，用二叉树的后序遍历。

import java.util.Arrays;

public class HeapSort {

    public static void minHeap(int[] array, int index, int heapSize) {
        // 下标从0开始，故左孩子2i＋1，右孩子2i＋2
        int left = index * 2 + 1;
        int right = index * 2 + 2;

        // 找出左右孩子中的较小者
        int min = index;
        if (left < heapSize && array[left] < array[min]) {
            min = left;
        }
        if (right < heapSize && array[right] < array[min]) {
            min = right;
        }

        // 替换父节点和较小者
        if (index != min) {
            swap(array, index, min);
            minHeap(array, min, heapSize);
        }
    }

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

    public static void heapSort(int[] arr) {
        // 建堆
        for (int i = (arr.length - 1) / 2; i >= 0; i--) {
            minHeap(arr, i, arr.length);
        }
        // 首尾交换，再次建堆
        for (int i = arr.length - 1; i > 0; i--) {
            swap(arr, 0, i);
            minHeap(arr, 0, i);
        }
    }

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

}