TopK问题（Java优先队列+构造堆实现）

1.构造堆实现【实现最小K个数，构造大顶堆实现】

class Solution {
    public int[] getLeastNumbers(int[] nums, int k) {
        
        int[] heap = new int[k];

        if(k<=0){
            return heap;
        }

        // add element from nums to heap, size=k
        for(int i=0;i<k;i++){
            add(heap,i,nums[i]);
        }

        // select top k from k to nums.length
        for(int i=k;i<nums.length;i++){
            if(nums[i]<heap[0]){  // val<heap[0](堆顶元素)
                heap[0]=nums[i];
                pop(heap);
            }
        }

        return heap;
    }

    private void add(int[] heap, int index, int val) {
        while(index>0){
            int parent = (index-1)/2;
            if(heap[parent]>=val){
                break;
            }
            heap[index] = heap[parent];
            index = parent;
        }
        heap[index]=val;
    }

    private void pop(int[] heap) {
        int root = 0;
        while((root*2+1)<heap.length) {
            int left = root*2 + 1;
            int right = root*2 + 2;
            if(right<heap.length && heap[right]>heap[left]) {
                left=right;
            }
            if(heap[left]<=heap[root]){
                break;
            }
            swap(heap,left,root);
            root=left;
        }
    }

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

2.Java PriorityQueue实现

public static void main(String[] args) {
        int[] nums = {4,2,3,1};
        int k = 2;
        int[] res = solve(nums,k);
        System.out.println(Arrays.toString(res));
    }

    private static int[] solve(int[] nums, int k) {
        if(k<=0){
            return new int[0];
        }
        Queue<Integer> queue = new PriorityQueue<>(k, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });

        for(int num:nums){
            if(queue.size()<k){
                queue.add(num);
            }else if(num<queue.peek()){
                queue.poll();
                queue.add(num);
            }
        }

        int[] res = new int[queue.size()];
        int idx = 0;
        while(!queue.isEmpty()){
            res[idx]=queue.poll();
            idx++;
        }
        return res;
    }