排序（堆排序）

堆排序基本介绍

• 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它是不稳定排序（相同的两个值排序后的先后顺序可能发生变化）。
• 堆是具有以下性质的完全二叉树
  • 每个结点的值都大于或等于其左右孩子结点的值，称为 大顶堆 ,如图1。 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。
  • 每个结点的值都小于或等于其左右孩子结点的值，称为 小顶堆 ，如图2。
  • 升序可以选择使用大顶堆，降序可以选择使用小顶堆
  • 根节点就是这个堆中最大（大顶堆）或最小（小顶堆）的那个元素。
• 堆排序用到了完全二叉树的顺序存储结构（即数组），所以顺序存储并不是完全无用，在这里会发挥大作用。

tips:一定要理解大顶堆、小顶堆、完全二叉树以及完全二叉树的顺序存储结构才能理解堆排序，这个是前提哟！！！

图1：大顶堆示例

图2：小顶堆示例

堆排序基本思路

1. 以升序排序来讲，先将数组arr（0 ~ arr.length-1）调整成一个堆。
   1.1 怎么调整？从0~arr.length-1的元素中的最后一个非叶子节点开始调整，这个叶子节点的下标是arr.length/2-1，设为x；
   1.2 这个叶子节点的左子节点的下标2*x+1，设为leftChild；右子节点的下标识2*x+2 ，设为rightChild。然后比较 arr[leftChild] 和 arr[rightChild] 的大小，假设 arr[leftChild] 更大，将 arr[leftChild] 再与 arr[x] 比较，如果 arr[leftChild]>arr[x]，将 arr[leftChild]和arr[x] 交换，使以x为根节点的这棵子树满足大顶堆的特点。
   1.3 x - -，重复1.2，直到x==0 。
2. 将数组 arr 调整成一个大顶堆后，堆的根节点，即 arr[0] 是数组中最大的那个数，将 arr[0]与arr[length-1] 交换，这时最大的元素就被交换到了数组尾部。
3. 交换了 arr[0]与arr[length-1] 后，原本调整好的堆的顺序就乱了，所以需要重新调整以 arr[0] 作为根节点的树，将其调整成一个新得大顶堆，不过这时候参与调整的元素不在是 0 ~ arr.length-1 ，而是 0 ~ arr.length-2，因为此时数组尾部已经是最大的那个数了，不需要在参加排序。重新调整成大顶堆后将 arr[0] 与 arr[length-2] 交换。交换后原本调整好的堆结构又变化了，这时又重新调整以 arr[0] 为根节点的树堆结构，不过参与调整的元素为 0 ~ length-3 ,调整好后又交换 arr[0] 与 arr[length-3]。然后又以 arr[0] 为根节点调整成大顶堆…这样不断调整、交换、调整、交换，直到要参与调整的元素是0~0。

介绍了这些，可能你还没怎么理解，建议自己写几个数来画画图，结合下面的代码，进一步理解堆排序，因为这的确不好说。

代码实现

/**
 * @author chenzhiyuan
 * @date 2019-10-17 23:39
 */
public class HeapSort {

    public static void heapSort(int[] nums) {
        // 从最后第一个非叶子节点开始将其对应的子树都调整成大顶堆
        // for循环结束，整个nums对应的完全二叉树就是一个大顶堆
        // 此时最大的元素就是nums[0]
        for (int i = nums.length / 2 - 1; i >= 0; i--) {
            adjuctHeap(nums, i, nums.length);
        }

        for (int i = nums.length - 1; i > 0; i--) {
            // 将nums[0]沉到数组尾部（nums[i]）
            swap(nums, 0, i);
            // 交换位置后，重新调整以nums[0]为根节点的树，参与调整的数据为0~i，i在不断递减，直到为0
            adjuctHeap(nums, 0, i);
        }
    }

    /**
     * 将以nums[root]作为根节点的子树调整为大顶堆
     *
     * @param nums   待排序的数组
     * @param root   表示当前要调整成大顶堆的子树的根节点的下标，注意不一定是整个nums对应的树的根，还可能是子树的根
     * @param length 参与调整的元素的个数，也就是思路介绍中第一次是对0~nums.length的元素调整，第二次是以0~nums.length-1的元素调整...
     */
    private static void adjuctHeap(int[] nums, int root, int length) {
        for (int k = root * 2 + 1; k < length; k = k * 2 + 1) {
            // 比较左右孩子的大小，root * 2 + 1是左孩子的下标
            if (k + 1 < length && nums[k] < nums[k + 1]) {
                k++;
            }
            // 比较根节点和和nums[k]的大小
            if (nums[k] > nums[root]) {
                swap(nums, root, k);
                // 重置root为k
                root = k;
            } else {
                break;
            }
        }
    }

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

}

测试耗时

// 创建随机数
    public static int[] createNum(int size, long seed) {
        int[] nums = new int[size];
        Random random = new Random(seed);
        for (int i = 0; i < nums.length; i++) {
            nums[i] = random.nextInt(1000);
        }
        return nums;
    }


    // 测试5轮
    public static void testTime(int size) {
        // 使用不同的种子，使每一轮测试的随机数不一样
        // 种子也可以用于其他排序，因为Random是个伪随机数类，
        // 只要种子相同，两个Random对象产生的随机数也一样，
        // 利用这个特点在测试其他排序时，使用种子一样，他们排序的数据
        // 也一样
        int[] seeds = new int[]{9999, 8888, 7777, 6666, 5555};

        int[] nums = createNum(size, seeds[0]);
        long start = System.currentTimeMillis();
        heapSort(nums);
        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start) + "ms");

        nums = createNum(size, seeds[1]);
        start = System.currentTimeMillis();
        heapSort(nums);
        end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start) + "ms");

        nums = createNum(size, seeds[2]);
        start = System.currentTimeMillis();
        heapSort(nums);
        end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start) + "ms");

        nums = createNum(size, seeds[3]);
        start = System.currentTimeMillis();
        heapSort(nums);
        end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start) + "ms");

        nums = createNum(size, seeds[4]);
        start = System.currentTimeMillis();
        heapSort(nums);
        end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start) + "ms");
    }

结果如下：

>二十万数据
  耗时：56ms
  耗时：49ms
  耗时：38ms
  耗时：40ms
  耗时：36ms
>一千万数据
  耗时：2037ms
  耗时：1747ms
  耗时：1937ms
  耗时：1705ms
  耗时：1703ms