堆、堆排序

一、完全二叉树
一棵树要么是满的，要么在满的路上

二、堆的概念与实现
堆就是完全二叉树，也叫优先级队列
堆可以由数组来实现，先定义一个比较大的数组长度，而真正有用的、代表了堆结构的数组的长度小于数组实际长度；

三、大根堆与小根堆的概念
当一棵完全二叉树，包括它本身和它的所有子树在内，的根节点大于等于所有孩子的值的时候，此完全二叉树被称为大根堆；
小根堆类似；

四、HeapInsert
向一个堆里添加一个数，让它向上看，如果说大于父节点就让它交换，实现上浮

/*传递过来的时候，index对应的数值已经在数组当中了*/
/*如果说此节点的值大于父节点的值，交换父子节点的值，再获取父节点的下标，重复；
 * 直到子节点的值不大于父节点的值，或者已经到了根节点，即自己和自己比,那必然跳出while
 * */
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
向一个堆中传递一个数，让它向下看，如果小于自己的某个子节点就交换，实现下沉；

代码解释：获取自己的左孩子，判断左孩子是否存在；如果有右孩子，则对两个孩子进行比较，选取数值较大的那个孩子，如果没有右孩子就返回左孩子；将大的那个孩子和父节点进行比较，返回较大的节点，如果说这个节点就是父节点，那父节点就是最大的，可以直接结束循环；如果说不是，那就将父子节点交换；交换之后，子节点作为新的父节点，获取新的父节点的左孩子，在while中重复上述操作即可；

public static void heapIfy(int[] arr, int index, int heapSize) {
    int left = 2 * index + 1;
    while (left < heapSize) {
        int largest = left + 1 < heapSize && arr[left] < arr[left + 1] ? left + 1 : left;
        largest = arr[largest] > arr[(largest - 1) / 2] ? largest : (largest - 1) / 2;
        if (index == largest)
            break;
        swap(arr, index, largest);
        index = largest;
        left = 2 * index - 1;
    }
}

置换方法：

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

六、比较器
如果想让一个东西降序排列，即大的排前面小的排后面，在写比较器的时候，如果后一个参数大于前一个参数，就该抓取到后一个参数，即返回一个正数，故它的代码：

public static class MyComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}

Insert和Ify的时间复杂度都是logN(2为底数)级别的；

七、堆排序

拿给我一个数组，首先将它通过heapInsert方法转换成大根堆，此步骤叫建堆；
然后将根节点（最大的那个数）和最后一个结点交换位置，把它打印出来（或执行其他操作），再逻辑删除（heapSize- -）；
把交换到根节点的那个数通过heapIfy方法下沉；
重复上述操作，直到heapSize为0；
时间复杂度为O(N*LogN)

代码分析：首先让整个数组变成大根堆；再将heapSize自减1后，完成根节点(0)和最后一节点(heapSize - -)的交换；在heapSize小于0之前，先让交换过后的根节点下沉，heapSize - - ，再交换，循环往复；

细节分析：假设有heapSize = n，即有 n +1个元素，先让heapSize减一，当前heapSize为最后一个元素的下标，完成头尾交换，而且heapSize已经完成逻辑删除任务，即此时堆结构已经只有n个元素了，最大的那个元素已经被逻辑删除了；然后进入到while里面，因为刚刚交换了一下头尾，现在的头部肯定不是最大的，所以对头部进行下沉，下沉完成后，又形成了新的大根堆，再对这个大根堆进行头尾交换，这个数组里面第二大的数也被排到了堆的外面；循环往复，即可排好；

public static void heapSort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        heapInsert(arr, i);
    }
    for (int i : arr) {
        System.out.print(i);
    }
    System.out.println("\n==============");
    int heapSize = arr.length;
    swap(arr, 0, --heapSize);
    while (heapSize > 0) {
        heapIfy(arr, 0, heapSize);
        swap(arr, 0, --heapSize);
    }
    for (int i : arr) {
        System.out.print(i);
    }
}