例题集 堆

1. 建立大根堆
2. 每插入一个数建立大根堆
3. 当一个数改变时，将这个数组调整为大根堆
4. 用堆排序求中位数

1. 建立大根堆
给定一个数组，将这个数组变成大根堆

思想：
从arr[0]开始，假设arr[0]已经是一个大根堆，那么从arr[1]~arr[arr.length - 1]看作依次插入数组的一个数，在此基础上排序成大根堆

public class createHeap {
	//测试
    public static void main(String[] args) {
        int[] arr = {7,7,5,1,2,3,6,9,8,1,2,3,9,4,1,6};

        createheap(arr);
        for (int a : arr){
            System.out.println(a);
        }
    }
	//建立大根堆
    private static void createheap(int[] arr) {
		//从arr[0] ~ arr[arr.length - 1]
        for (int i = 0;i<arr.length;i++){
        	//插入大根堆排序
            while (arr[i] > arr[(i - 1)/2]){
                swap(arr,i,(i - 1)/2);
                i = (i - 1)/2;
            }
        }
    }

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

2.每插入一个数建立大根堆
思想：
对插入数的下标判断，与他的父结点arr[(index-1)/2]相比，若大于父结点则交换位置，交换位置后在于它的父结点相比，直到已经是根结点为止

public class heapInsert {

    public static void main(String[] args) {
        int[] arr = {7,7,5,1,6,2};

        heapinsert(arr,arr.length - 1);
        for (int a : arr){
            System.out.println(a);
        }
    }

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

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

3. 当一个数改变时，将这个数组调整为大根堆
思想：
获取改变的数的下标，
先左右孩子进行判断找到一个最大值
再将孩子中的最大值与该数判断
如果 arr[左右] > arr[index]，交换位置，重复循环
如果arr[左右] <=arr[index],结束

public class heapiFy {

    public static void main(String[] args) {
        int[] arr = {1,7,6,7,2,3,5,1};

        heapify(arr,0,arr.length);
        for (int a:arr){
            System.out.println(a);
        }
    }

    private static void heapify(int[] arr, int index, int heapSize) {
        
        //左孩子
        int left = index*2 + 1;

        //判断是否越界
        //当这个数的左孩子少于数组长度时，必然没有越界
        //index*2+1 = arr.length -1 时刚好是最后一个数
        //那么 index*2+1 < arr.length 时,来判断循环是否进行
        while (left < heapSize){
            //从左右孩子中找到一个最大值
            int largest = (left + 1) < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;
            //再比较左右孩子的最大值 和 当前数
            largest = arr[largest] > arr[index] ? largest : index;

            //判断 如果当前数已经是最大值 那么结束
            //如果当前数不是最大值，那么继续循环
            if (largest == index){
                break;
            }else {
                swap(arr,index,largest);
                index = largest;
                left = index*2+1;
            }
        }
    }

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

4.用堆排序求中位数