堆排序（Java）

堆排序：堆排序的思想比较难理解，首先将数据看成是一个二叉树，对数据进行二叉树的建立（建堆），这个过程也是排序的过程，将最小或最大的值排到根节点上，如果采用最大值，则称为最大堆，反之，称为最小堆
例如：有一个数组为[8,1,4,2,3],将他变为二叉树为：

        8
    1     4
2    3

要对它进行排序，可以从8开始，和他的左孩子和右孩子比较，将小的那个和本身进行替换，第一次替换变为：

        1
    8     4
2    3

再以替换的节点作为父节点，和他的左孩子和右孩子比较，将小的和本身那个交换

        1
    2     4
8    3

另外我们观察索引发现，当前节点索引 * 2 + 1即为左孩子的索引，当前节点索引 * 2 + 2即为右孩子索引
实现代码：

    /**
     * 建堆
     *
     * @param nums
     * @param size
     * @param index
     */
    private void createHeap(int[] nums, int size, int index) {
        //数组索引：0 1 2 3 4 5 6
        //0的左孩子索引是1 ，0的右孩子索引是2
        //1的左孩子索引是3，右孩子是4
        //2的左孩子索引是5，右孩子是6
        //得出：
        int leftIndex = 2 * index + 1;//左孩子索引
        int rightIndex = leftIndex + 1;//右孩子索引

        //将当前节点、左孩子、右孩子的值进行比较，较小的值和当前节点替换
        if (leftIndex >= size && rightIndex >= size) {//没有孩子，不用处理了
            return;
        }

        int currentValue = nums[index];
        int leftValue = leftIndex < size ? nums[leftIndex] : Integer.MAX_VALUE;//可能没有（代码走到这，左孩子其实不可能没有）
        int rightValue = rightIndex < size ? nums[rightIndex] : Integer.MAX_VALUE;//可能没有

        if (currentValue <= leftValue && currentValue <= rightValue) {//当前节点已经小了，不用处理
            return;
        }

        if (leftValue < rightValue) {//左孩子替换当前节点
            nums[index] = leftValue;
            nums[leftIndex] = currentValue;
            createHeap(nums, size, leftIndex);
        } else {//右孩子替换当前节点
            nums[index] = rightValue;
            nums[rightIndex] = currentValue;
            createHeap(nums, size, rightIndex);
        }
    }

但是我们发现自上而下建立二叉树，是不可行的
比如：数组为：[8,2,4,1,3]
二叉树为：

        8
    2     4
3    1

那么调用我们代码后形成的树为：

        2
    1     4
3    8

最小值1，并没有到达根节点，这时转变思路，不用从根节点开始建立，而是从树的底部开始建立堆，过程为：
先将1，2，3进行排序

        8
    1     4
3    2

然后1，4，8进行排序

        1
    8     4
3    2

思想就是从最深度- 1的深度的倒数第一个节点开始倒着建堆，以上面的数据就是从4开始，由于是完全二叉树，所以索引为：(数组大小 - 1) / 2
实现代码：

    /**
     * 自下而上建堆
     *
     * @param nums
     */
    public void buildHeap(int[] nums) {
        for (int i = (nums.length - 1) / 2; i >= 0; i--) {
            createHeap(nums, nums.length, i);
        }

        //取出最小的
        int n = nums.length;
        while (n > 0) {
            System.out.print(nums[0] + " ");
            nums[0] = nums[n - 1];
            n--;
            createHeap(nums, n, 0);
        }
    }

测试代码：

        int[] nums = new int[]{5, 7, 1, 3, 9, 0, 1, 6, 8, 4};
        buildHeap(nums);

结果：
0 1 1 3 4 5 6 7 8 9
堆排序本身用来排序性能并不高，但是作为查找的时候性能很高，由于二分查找只针对已经排好序的顺序表，对于大数据量的散列表，推排序就可以出场了，因为推排序的建堆过程，尽可能少的访问节点，减少了对一个节点的重复访问，而又具有二分的思想，相比于其他排序，查找性能非常高