1. 最大堆的数组化表示

假设有一个数组 int[] arr = {8,9,10,11,12,13,14};
用它来构建最大堆

2. 基本思路

1. 最大堆或最小堆都是完全二叉树，利用这个性质，先按照数组顺序构建最简单的完全二叉树
2. 从最后一个节点的父节点（arr.length / 2 - 1）开始 逐次调整位置，开始构建最大堆
   2.1 若父节点小于左节点，父节点与左节点互换，继续调整
   2.2 若父节点小于右节点，父节点与右节点互换（注意是经过2.1），继续调整

3. 构建示意图

image.png

4. 源代码

static int[] arr = {8, 9, 10, 11, 12, 13, 14};

    public static void main(String[] args) {
        /*
         * 调用建立大顶堆方法：
         * index：传入最后一个非叶子节点，即list.size()/2-1;
         * */

        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            buildHeap(arr, i, arr.length);
        }
        System.out.println("输出最大堆：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        System.out.println("升序排列结果：");
        heapSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
    public static void buildHeap(int[] arr, int index, int size) {
        int leftchild = 2 * index + 1;
        int rightchild = 2 * index + 2;
        int temp = index;
        if (leftchild < size && arr[index] < arr[leftchild]) {
            index = leftchild;
        }
        if (rightchild < size && arr[index] < arr[rightchild]) {
            index = rightchild;
        }
        if (index != temp) {
            swap(arr, temp, index);
            // 交换后继续向下调整,以index为父节点，继续向下调整
            buildHeap(arr, index, size);
        }
    }

    /*
     * 堆排序：
     *      1)将已经建立好的大顶堆，每次取出根节点，即最大值。
     *      2)将最后一个节点的值赋给根节点，重新构建大顶堆。
     *      3)删除最后节点的数据
     * */
    public static void heapSort(int[] arr) {
        for (int i = arr.length - 1; i >= 0; i--) {
            swap(arr, i, 0);
            // 从根节点向下调整，每次取出一个数值，集合长度逐渐减小
            buildHeap(arr, 0, i);
        }
    }

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

5 堆排序

基本思路
1)将已经建立好的大顶堆，每次取根节点，即最大值，并与最后的节点交换。
2)重新构建大顶堆，注意索引是从int i = arr.length - 1 开始的，重建大顶堆时，实际上相当于删除了最后一个元素，即删除了刚刚完成第一步交换的最大值。对于数组来说，刚好是将最大值，固定在最后的索引上。