堆排序解析

什么是堆

堆是按照特定规则将数组转化为一颗完全二叉树的一种数组结构，堆本质上遵循了一种规则，但本身上一种数组。

大根堆

树上所有节点满足：父节点总是大于子节点的树，叫大根堆

小根堆

树上所有节点满足：父节点总是小于子节点的树，叫小根堆

数组转化二叉树

数组转二叉树，i为数组下标
左节点 2i+1
右节点 2i +2
父节点 (i-1)/2

heapInsert

维持大根堆，插入的节点和父节点比较，维持大根堆

	public static void heapInsert(int[] arr, int index) {
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2);
            index = (index - 1) / 2);
        }
    }

heapify

把节点向下调的过程，与子节点中较大的节点交换。因为要是交换较小的节点以后，那么这个节点调上去之后子节点都比自己大，这就破坏了大根堆的结构。
适用场景：某元素的值变小，需要调整大根堆
时间复杂度：O(logN)

如果元素的值变化，但不知道是变大还是变小，可以同时尝试heapify和heapInsert，因为只会发生其中的一个操作，所以时间复杂度为O(logN)。

	public static void heapify(int[] arr, int index, int size) {
        int left = index * 2 + 1;
        while (left < size) {
            int largest = left + 1 < size && arr[left] < arr[left + 1] ? left + 1 : left; // 这个条件很重要
            largest = arr[index] < arr[largest] ? largest : index;
            if (largest == index) {
                break;
            }
            swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;
        }
    }

堆排序

堆排序就是先把未排序的数组调整成大根堆（以升序为例，如果是降序，则需要调整为小根堆），然后每次都把大根堆的堆顶调整到最后，再把堆的大小减去1。因为堆的大小变小了，我们再把这个堆继续调整为大根堆，把堆顶调整到最后，再把堆的大小减1，周而复始，直到堆的大小变为0。由于每次调整堆后都把堆顶的置换到最后，所以我们得到的最终结果一定是一个排序的数组。
思路：
1.把数组变成大根堆（heapInsert）
2.a[0]与a[size-1]交换
3.把a[0]向下heapify
4.重复2、3，直到size=0
时间复杂度：O(n*logN)

public class HeapSort {

    public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

		//先把数组调整成大根堆
        for (int i = 0; i < arr.length; i++) { // O(n)
            heapInsert(arr, i); //O(nlogN)
        }
		//由于大根堆的第一个节点最大，所以直接把它调到最后
        int size = arr.length;
        swap(arr, 0, --size);

        while (size > 0) { // O(n)
            heapify(arr, 0, size); // O(logN)
            swap(arr, 0, --size);
        }
    }

    public static void heapInsert(int[] arr, int index) {
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2);
            index = (index-1)/2
            
        }
    }

    public static void heapify(int[] arr, int index, int size) {
        int left = index * 2 + 1;
        while (left < size) {
            int largest = left + 1 < size && arr[left] < arr[left + 1] ? left + 1 : left; // 判断右孩子是否存在，以及左右孩子哪个比较大
            largest = arr[index] < arr[largest] ? largest : index;
            if (largest == index) {
                break;
            }
            swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;
        }
    }

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



}