Top K问题

思路：

1. 堆排序，维护大小为k的堆；
2. 快排，利用分治思想，递归分治，直到某次分治后，其中一部分元素数量为k。

比较：
看起来分治法的快速选择算法的时间、空间复杂度都优于使用堆的方法，但是要注意到快速选择算法的几点局限性：

第一，算法需要修改原数组，如果原数组不能修改的话，还需要拷贝一份数组，空间复杂度就上去了。

第二，算法需要保存所有的数据。如果把数据看成输入流的话，使用堆的方法是来一个处理一个，不需要保存数据，只需要保存 k 个元素的最大堆。而快速选择的方法需要先保存下来所有的数据，再运行算法。当数据量非常大的时候，甚至内存都放不下的时候，就麻烦了。所以当数据量大的时候还是用基于堆的方法比较好。

package Java;

import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Queue;
 
public class Test {
    // 一、堆方法(优先队列)
    // 堆的性质是每次可以找出最大或最小的元素
    // 快排变形
    public static void main(String[] args) {
        int[] arr = new int[] { 1, 2, 34, 4, 5, 6 };
        //int[] nums = getLeastNumbers(arr, 3);
        int[] nums=getLeastNumbersTwo(arr,3);
        System.out.println(Arrays.toString(nums));
    }
 
    public static int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0)
            return new int[0];
        // 使用一个最大堆（大顶堆）
        Queue<Integer> heap = new PriorityQueue<>(k, (i1, i2) -> Integer.compare(i2, i1));
        for (int e : arr) {
            // 当前数字小于堆顶元素才会入堆
            if (heap.isEmpty() || heap.size() < k || e < heap.peek())
                heap.offer(e);
            // 删除堆顶最大元素，只保留k个
            if (heap.size() > k)
                heap.poll();
        }
        // 将堆中的元素存入数组
        int[] res = new int[heap.size()];
        int j = 0;
        for (int e : heap)
            res[j++] = e;
        Arrays.sort(res);
        return res;
    }
 
	// 二、快排方法
    public static int[] getLeastNumbersTwo(int[] arr, int k) {
        if (k == 0)
            return new int[0];
        else if (arr.length <= k)
            return arr;
 
        // 递归，分治
        quick(arr, 0, arr.length - 1, k);
         
        // 分治结束，数组的前 k 个数此时就是最小的 k 个数，将其存入结果
        int[] res = new int[k];
        for (int i = 0; i < k; i++)
            res[i] = arr[i];
         
        return res;
    }
 
    static void quick(int[] arr, int left, int right, int k) {
        // 做一次partition 操作，返回哨兵位置
        int m = partition(arr, left, right);
        // 若此时分开的两组，前面刚好有k个，即找到了topK
		if(k==m) return;
		// 否则继续快排，根据两边部分元素数量选择对哪一个部分进行快排
        else if(k<m) quick(arr, left, m-1, k);  // 最小的 k 个数一定在前 m 个数中，递归划分
        else quick(arr, m+1, right, k); // 在右侧数组中寻找最小的 k-m 个数
    }
 
	// 返回一次分治后的烧饼位置
	static int partition(int[] arr, int low, int high) {
        int base = arr[low];
        while (low < high) {
            // 判断条件必须加=场景，为<= 不能为<，否则数组中有相同数据时，会一直循环
            while (low < high && base <= arr[high]) {
                high--;
            }
            arr[low] = arr[high];
            
            // 判断条件必须加=场景，为>= 不能为>，否则数组中有相同数据时，会一直循环
            while (low < high && base >= arr[low]) {
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = base;
        return low;
    }
}