堆排

堆排序
1）先将数组变成一个大根堆
2）将堆顶位置和数组中的最后一个数交换，让堆的大小减一，让剩下的数做heapify
3）每次都这么干，直到堆的大小减完
！！！堆的问题很重要，几乎所有的贪心问题都需要用堆实现

代码实现：

package basic_class_01;

//堆排序
//1）先将数组变成一个大根堆
//2）将堆顶位置和数组中的最后一个数交换，让堆的大小减一，让剩下的数做heapify
//3）每次都这么干，直到堆的大小减完
//！！！堆的问题很重要，几乎所有的贪心问题都需要用堆实现
public class HeapSort {
    public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            heapInsert(arr, i);    //  每次 0-i 上排 大根堆
        }
//        上面已经形成了大根堆
        int heapsize = arr.length;
        swap(arr, 0, --heapsize);//让0位置和数组中的最后一个位置交换，堆的大小减一
//        让堆的大小最后减没
        while (heapsize > 0) {
            heapfy(arr, 0, heapsize);//由于刚才交换，大根堆的堆顶此时是数组中最小的数，需要向下沉
            swap(arr, 0, --heapsize);//新生成的大根堆，再次将堆顶的数和数组中的最后一个数交换，堆的大小减一
        }
    }

    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;
        }
    }

    //    heapfy过程是由于index位置上的数变小了，所以这个数要往下沉，heapsize是范围0~heapsize-1的数
    public static void heapfy(int[] a, int index, int heapsize) {
        int left = index * 2 + 1;
        while (left < heapsize) {//看左孩子是否越界
//            比较左孩子和右孩子，largest等于大的那个，先判断右孩子是否越界
            int largest = left + 1 < heapsize && a[left + 1] > a[left] ? left+1 : left;
//            用左孩子和右孩子中大的那个和自己做比较，largest等于大的那个
            largest = a[largest] > a[index] ? largest : index;
//            如果自己是最大的，那么直接跳出while循环，因为不用往下沉
            if (largest == index) {
                break;
            }
//            如果自己不是最大的，那么和左孩子右孩子中较大的那个作交换
            swap(a, largest, index);
//            将大数换上去之后，将当前数指向刚才交换的那个孩子节点，接着往下比较，如果大再往下沉
            index = largest;
//            该数的左孩子
            left = index * 2 + 1;
        }
    }

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

    public static void main(String[] args) {
        int[] a = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
        heapSort(a);
        for (int i : a) {
            System.out.print(i);
        }
    }
}

堆结构讲解（一个实例）：

    堆结构讲解：
    一个大根堆，一个小跟堆，一组数据流，流进大根堆和小跟堆
    求每流进一个数后，数据流的平均数
    先放进大根堆一个数，下一个数如果小于等于大根堆的数，就放进大根堆，如果大于大根堆的数就放进小跟堆
    如果大根堆中数的个数和小跟堆中的数的个数差值大于1
    如果大根堆比小跟堆多两个，那么就将大根堆的堆顶弹到小跟堆的堆顶
    如果小跟堆比大根堆多两个，那么就将小跟堆的堆顶弹到大根堆的堆顶
    这样数据流就流进大根堆和小跟堆中，中位数=（大根堆的堆顶+小跟堆的的堆顶）/2