堆排序（likou 912）

912. 排序数组

难度中等

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：

输入：nums = [5,2,3,1]
输出：[1,2,3,5]

示例 2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

 提示：

1. 1 <= nums.length <= 50000
2. -50000 <= nums[i] <= 50000

使用堆排序的方式解决这个问题:

 怎么实现的呢，

其实思想就是利用数组表示堆（完全二叉树）

例如上图，节点0的左子树和右子树分别是1，2；

其实就是 0 * 2 + 1 = 1（i * 2 + 1 = k，因为分层都是上一层的二倍）得到左子树，根据左子树的节点大小是否小于len - 1（数组长度），如果小于说明存在该节点的右子树，然后1节点的左子树和右子树分别是3、4，即1 * 2 +1 == 3

还有这个完全二叉树的第一个非叶子节点必然是 len  / 2 - 1，因为完全二叉树的节点是从0开始计算的（最后一层叶子节点可以占二叉树的一半）

然后就是从最底层非叶子节点开始调节二叉树，最终形成最大堆，上层调节时会向下层判断是否满足最大堆的条件，下层只需判断自己和比自己下层是否满足最大堆即可，因为最后执行的时根节点（最上层），i == 0时是根节点，（从下层开始调节）

        for (int i = nums.length / 2 - 1; i >= 0; i--) {
            adjustHeap(nums, i, nums.length);
        }

然后就是把最后一个节点与根节点交换（最大值移动到数组的最后一个位置，然后再次调节成最大堆时，数组长度减一，这样就能形成（次最大堆（去掉最大值的堆）））。

public class Sort {

    public static void main(String[] args) {
        int[] nums = new int[]{1, 4, 2, 5, 3};

        Sort sort = new Sort();
        int[] flag =  sort.createHeap(nums);
        for (int i = 0; i < flag.length; i++) {
            System.out.print(flag[i] + " ");
        }
    }

    public int[] createHeap(int[] nums) {
        int agv = nums.length / 2 - 1;
        for (int i = agv; i >= 0; i--) {
            adjustHeap(nums, i, nums.length);
        }

        for (int j = nums.length - 1; j > 0; j--) {
            swap(nums, 0, j);
            adjustHeap(nums, 0, j);
        }
        return nums;

    }


    public void adjustHeap(int[] nums, int i, int len) {

        for (int j = i * 2 + 1; j < len; j = j * 2 + 1) {
            if ((j + 1) < len && nums[j] < nums[j + 1]) {
                j++;
            }
            if (nums[i] < nums[j]) {
                swap(nums, i, j);
                i = j;
            } else {
                break;
            }
        }
    }

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