十六、堆排序

一、堆排序

完全二叉树：完全二叉树从根结点到倒数第二层满足完美二叉树，最后一层可以不完全填充，其叶子结点都靠左对齐，堆就是完全二叉树
数组——完全二叉树(通过下标来维护彼此的关系)

大根堆：当前树(子树)中(包含子树)的最大值都是头部
小根堆：当前树(子树)中(包含子树)的最小值都是头部
数组——>大根堆

public class HeapSort {
    public static void main(String[] args) {
        int[] arr = new int[100];
        for (int i = 0; i < 100; i++) {
            arr[i] = (int)(Math.random() * 100);
        }
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        // 形成大根堆 复杂度：O(n)
        for (int i = 0; i < arr.length; i++) {
            // 0 ~ i 之间形成大根堆
            heapInsert(arr, i);
        }
        // 大根堆中节点的个数
        int heapSize = arr.length;
        // 堆顶位置的数和最后一个数交换，最大值来到了数组的最后，堆大小减 1，排除原来堆顶这个数
        swap(arr, 0, --heapSize);
        while (heapSize > 0) {
            // 交换完之后，调整当前堆顶元素的位置，从新形成一个大根堆，继续这个过程
            heapify(arr, 0, heapSize);
            // 堆顶位置的数和最后一个数交换，最大值来到了数组的最后，堆大小减 1，排除原来堆顶这个数
            swap(arr, 0, --heapSize);
        }
    }

    /**
     * heapSize：形成的大根堆的数组元素的数量
     * 0 ~ heapSize-1下标位置中 index位置节点的值变小往下沉的过程
     * 下降的过程就是 index位置元素和它的左右子节点中较大的交换位置
     * @param arr
     * @param index
     * @param heapSize 当前大根堆的节点数 <= arr.length
     */
    public static void heapify(int[] arr, int index, int heapSize) {
        // index位置所在节点的左子节点位置
        int left = index * 2 + 1;
        // 左子节点不越界，也在堆上时
        while (left < heapSize) {
            // （left+1）为右子节点的下标，如果右子节点不越界 && 左子节点的值 < 右子节点的值
            // largest就表示两个子节点中值较大节点在数组中的下标
            int largest = left + 1 < heapSize && arr[left] < arr[left + 1] ? left + 1 : left;
            // 当前节点的值和较大子节点的值比较，返回较大节点值的下标
            largest = arr[index] > arr[largest] ? index : largest;
            // 如果是本身较大，则不用下沉，此位置就是最终位置
            if (largest == index) {
                break;
            }
            // 较大的不是本身，则和较大的节点交换位置
            swap(arr, index, largest);
            // 修改当前下标为较大节点的下标
            index = largest;
            // 找当前下标位置对应的左子节点下标
            left = 2 * index + 1;
        }
    }

    /**
     * 将数组index位置的元素加入到大根堆中
     * @param arr
     * @param index 数组中当前元素的下标
     */
    public static void heapInsert(int[] arr, int index) {
        // 如果当前节点大于父节点，交换位置，直到不大于父节点
        // 当 index跳到 0位置后，(0-1)/2=0，0位置和0位置相等，跳出循环
        while (arr[index] > arr[(index - 1) / 2]) {
            // 当前节点和父节点交换
            swap(arr, index, (index - 1) / 2);
            // 当前节点跑到父节点的位置继续比较(和交换后的父节点比较)
            index = (index - 1) / 2;
        }
    }

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

堆的简单应用，求不断加入的数据整体的中位数