堆排序

简介

堆排序是将一个无序的数组看作一个完全二叉树，将完全二叉树构建成为一个大顶堆（或者小顶堆），构建完成后数组的第一个元素就是最大值（小顶堆是最小值），将第一个元素移动到数组最后位置，将剩余的数据看作一个新的数组，循环上面的操作，就可以完成排序。

前提知识

完全二叉树任意一个节点：R[i]
其左子节点为:R[2i+1]
其右子节点为:R[2i+2]
其父节点为:R[(i-1)/2]
最后一个非叶子节点为R[n/2-1],n为数组长度。

构建大顶堆

我认为堆排序的核心在于构建大顶堆（或小顶堆），构建完成之后就可以拿到最大值（或最小值），只要不断循环构建大顶堆就可以完成排序了。

思路

• 大顶堆的定义要求所有的非叶子节点均大于等于其子节点。
• 为了满足上述结果，我们先找到最后一个非叶子节点，判断此节点与其子节点大小，满足条件需要置换对应的值。
• 处理完最后一个非叶子节点后，依次向上排查，直到排查到根节点，完成大顶堆的构建。（最后一个非叶子节点为R[n/2 - 1],后续的非叶子节点坐标只需要在前一个叶子节点上减1就行了，非叶子节点坐标是连续的，画个图就能看出来了）
• 非叶子节点和其子节点调换之后会存在一个问题：其子节点可能还有子节点，这种置换可能会造成其子树不再是大顶堆了，所以每一次置换都要对所置换的子节点进行一次迭代，保证子树仍然是大顶堆。

实现

1.设置交换规则

传入一个节点下标，判断其与子节点的大小，如果做数值交换，需要对交换的子节点进行迭代，使子树仍然满足大顶堆：

    //传入一个坐标，交换父子节点，将最大的节点调换到父节点，length字段为数组长度
    public static void swap(int i, int[] a, int length) {
        //当前节点
        int me = a[i];
        //如果没有左节点,说明当前节点为叶子节点，不需要交换（没有左子节点肯定就没有右子节点了）
        if (2 * i + 1 >= length) {
            return;
        }
        //左子节点
        int left = a[2 * i + 1];

        //如果没有右节点
        if (2 * i + 2 >= length) {
            if (me < left) {
                a[i] = left;
                a[2 * i + 1] = me;
            }
            return;
        }

        //右子节点
        int right = a[2 * i + 2];

        //如果当前节点小于子节点
        if (me < left || me < right) {
            //如果左节点大于等于右节点，调换左节点与当前值
            if (left >= right) {
                a[i] = left;
                a[2 * i + 1] = me;
                //交换后有可能影响子树结构，对子树进行迭代
                swap(2 * i + 1, a, length);
            } else {
                //否则调换右节点
                a[i] = right;
                a[2 * i + 2] = me;
                //交换后有可能影响子树结构，对子树进行迭代
                swap(2 * i + 2, a, length);
            }
        }
    }

2.构建大顶堆

从最后一个非叶子节点依次向上排查与调换，当排查到根节点就完成了大顶堆的构建：

 //构建大顶堆，length字段为数组长度
    public static void myHeap(int[] a, int length) {
        //获取最后一个非叶子节点坐标
        int index = length / 2 - 1;
        //从右向左，从下向上循环调整数值，构建大顶堆
        for (; index >= 0; index--) {
            swap(index, a, length);
        }
    }

3.堆排序

构建大顶堆之后就能找到数组最大值，将最大值移到最后，将剩余元素看作新的数组重新构建大顶堆，循环之后就能完成排序：

//将最大值移到最后，进行堆排序
    public static void mySort(int[] a) {
        //将最大值移动到数组尾端，将未排序部分看作新的数组重新构建大顶堆
        for (int length = a.length; length > 0; length--) {
            myHeap(a, length);
            System.out.println("数组长度为[" + length + "]的大顶堆:" + Arrays.toString(a));
            //交换首尾元素
            int first = a[0];
            a[0] = a[length - 1];
            a[length - 1] = first;
        }
    }

4.main方法

验证结果:

 public static void main(String[] args) {
        //设置一个无序数值
        int a[] = {4, 5, 8, 7, 9, 4, 3, 2, 1, 0};

        mySort(a);
        System.out.println("堆排序结果："+Arrays.toString(a));
    }