算法

要点：将数组作为堆结构，利用大根堆根最大的性质，构建完就将根与未排序部分的末尾交换，逐步实现有序。

import java.util.Random;

public class HeapSort<T extends Comparable> {

    public void sort(T[] arr) {
        printArr(arr, " => 初始数组");
        for (int i = arr.length - 1; i > 0; i--) {
            // 构建大跟堆
            buildHeap(arr, 0, i);
            printArr(arr, " => 构建大根堆");
            // 最大值依次往后放，进行排序
            swap(arr, 0, i);
            printSign(0, i);
        }
    }

    /**
     * 从上向下构建大根堆
     * 很多大跟堆是从下向上构建的
     *
     * @param arr 原数组
     * @param rootIndex 根坐标
     * @param end 堆大小
     */
    private void buildHeap(T[] arr, int rootIndex, int end) {
        // 左子节点
        int leftChildIndex = rootIndex * 2 + 1;
        // 如果左子节点超出堆的大小就退出
        if (leftChildIndex > end) {
            return;
        }
        // 如果根比左子节点小就交换
        if (arr[rootIndex].compareTo(arr[leftChildIndex]) < 0) {
            swap(arr, rootIndex, leftChildIndex);
            // 交换可能会出现规则破坏，回溯一下
            backCheck(arr, rootIndex);
        }
        // 继续构建堆
        buildHeap(arr, leftChildIndex, end);
        // 右子节点
        int rightChildIndex = rootIndex * 2 + 2;
        // 如果右子节点超出堆的大小就退出
        if (rightChildIndex > end) {
            return;
        }
        // 如果根比右子节点大就交换
        if (arr[rootIndex].compareTo(arr[rightChildIndex]) < 0) {
            swap(arr, rootIndex, rightChildIndex);
            backCheck(arr, rootIndex);
        }
        // 继续构建堆
        buildHeap(arr, rightChildIndex, end);
    }

    /**
     * 向上追溯，查看是否乱序
     * 例：                                     树的坐标规律
     * 0,1,2,3,4 => 坐标                            0
     * 3,6,7,9,8 => 开始构建大跟堆                   1 2
     * 3,6       => 发现6比3大交换                  34 56
     * 6,3,9     => 发现9比3大交换
     * 6,9,3     => 如果在这里不追溯的话，就会出现不符合大跟堆规律的情况
     * 9,6,3     => 追溯发现根节点的父节点比根小，就交换，继续追溯，发现坐标已经为0了，就停下
     *
     * @param arr       数组
     * @param rootIndex 根坐标
     */
    private void backCheck(T[] arr, int rootIndex) {
        if (rootIndex == 0) {
            return;
        }
        int fatherIndex = (rootIndex - 1) / 2;
        if (arr[fatherIndex].compareTo(arr[rootIndex]) < 0) {
            swap(arr, fatherIndex, rootIndex);
        }
        backCheck(arr, fatherIndex);
    }

    private void swap(T[] arr, int a, int b) {
        T temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    private void printSign(int a, int b) {
        String[] arr = new String[]{" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "};
        arr[a] = "^";
        arr[b] = "^";
        for (String n : arr) {
            System.out.print(n);
        }
        System.out.println(" => 交换");
    }

    public void printArr(T[] arr, String message) {
        for (T n : arr) {
            System.out.print(n);
        }
        System.out.print(message);
        System.out.println();
    }

    public static void main(String[] args) {
        int n = 11;
        Integer[] arr = new Integer[n];
        for (int i = 0; i < n; i++) {
            arr[i] = new Random().nextInt(10);
        }
        HeapSort hs = new HeapSort();
        hs.sort(arr);
    }

    /**
     * 92134594608 => 初始数组
     * 98946152304 => 构建大根堆
     * ^         ^ => 交换
     * 96844152309 => 构建大根堆
     * ^        ^  => 交换
     * 84634150299 => 构建大根堆
     * ^       ^   => 交换
     * 64523140899 => 构建大根堆
     * ^      ^    => 交换
     * 53402146899 => 构建大根堆
     * ^     ^     => 交换
     * 43402156899 => 构建大根堆
     * ^    ^      => 交换
     * 42301456899 => 构建大根堆
     * ^   ^       => 交换
     * 31204456899 => 构建大根堆
     * ^  ^        => 交换
     * 20134456899 => 构建大根堆
     * ^ ^         => 交换
     * 10234456899 => 构建大根堆
     * ^^          => 交换
     *
     * => 遍历次数：log(n) + log(n-1) + log(n-2) + ... + log(1)
     * => 时间复杂度：O(nlogn)
     * => 稳定性：不稳定
     *
     * 例：
     * 0,1,2,3,5 => 坐标
     * 7,1,3,3,2 => 原数组
     * 7,1,3     => 3比1大交换
     * 7,3,3,1,2 => 交换后的数组 => 3的顺序发生改变，因此不稳定
     */

}