堆排序取topK

1、堆排序取最大K个

public class Test {
	public static void main(String[] args) {
        int[] arr = {19, 8, 27, 6, 315, 14, 99, 34, 27};
        int k = 3;
        //构建一个K容量的堆，堆顶为最小值（小顶堆存最大值）
        //从最后一个非叶子节点开始调整
        for(int i=k/2-1;i>=0;i--){
            adjustMin(arr,i,k);
        }
        //从K到之后的元素依次与堆顶比较，比堆顶大则交换，然后再调整里面的堆
        for(int i=k;i<arr.length;i++){
            if(arr[i]>arr[0]){
                arr[0]=arr[i];
                adjustMin(arr,0,k);
            }
        }
        for(int i=0;i<k;i++){
            System.out.println(arr[i]);
        }
    }

    //调整堆
    public static void adjustMin(int[] arr, int i, int length) {
        int temp=arr[i];  //保存父节点的值
        for(int k=2*i+1;k<length;k=k*2+1){
            if(k+1<length&&arr[k]>arr[k+1]){           //左孩子>右孩子，则取右孩子
                k++;
            }
            if(temp<=arr[k]){
                break;
            }else{            //根节点>左右孩子结点，则交换
                arr[i]=arr[k];
                i=k;
            }
        }
        arr[i]=temp;
    }
}

2、堆排序取最小K个

public class Test {
    public static void main(String[] args) {
        int[] arr = {19, 8, 27, 6, 315, 14, 99, 34, 27};
        int k = 3;
        //建初始堆
        for(int i=k/2-1;i>=0;i--){
            adjustMax(arr, i, k);
        }
        for(int i=k;i<arr.length;i++){
            if(arr[i] < arr[0]){
                arr[0] = arr[i];
                adjustMax(arr, 0, k);
            }
        }
        for(int i=0;i<k;i++){
            System.out.println(arr[i]);
        }
    }
    
    public static void adjustMax(int[] arr, int index, int k){
        int temp = arr[index];
        for(int i=2*index+1;i<k;i=2*i+1){
            if(i+1<k && arr[i+1]>arr[i]){
                i++;
            }
            if(temp >= arr[i]){
                break;
            }
            else{
                arr[index] = arr[i];
                index = i;
            }
        }
        arr[index] = temp;
    }
}

3、堆排序进行整体排序

public class Test {
    public static void main(String[] args) {
        int[] arr = {19, 8, 27, 6, 315, 14, 99, 34, 27};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void heapSort(int[] num) {
        // 调整0~num.length-1的数据，从最一个非叶子节点开始
        for (int i = num.length / 2 - 1; i >= 0; i--) {
            adjust(num, i, num.length);
        }

        for (int j = num.length - 1; j >= 0; j--) {
            // 交换堆顶元素到最后
            int tem = num[0];
            num[0] = num[j];
            num[j] = tem;
            // 再次调整0~j-1的数据
            adjust(num, 0, j);
        }
    }

    private static void adjust(int[] num, int root_index, int length) {
        int root = num[root_index];
        for (int j = root_index * 2 + 1; j < length; j = j * 2 + 1) {
            // 最大的儿子
            if (j + 1 < length && num[j] < num[j + 1]) {
                j = j + 1;// 指向了最大的儿子
            }
            if (root < num[j]) {
                num[root_index] = num[j];
                root_index = j;// 标记换了哪一个位置
            } else {
                break;// 已经是大顶堆了，不需要调整了
            }
        }
        num[root_index] = root;
    }
}

// 输出：[6, 8, 14, 19, 27, 27, 34, 99, 315]