使用优先队列实现求第k大或者第k小，前k大，前k小，力扣347题的解决。

1. 求前k大的数

public static void main(String[] args) {
    int[] arr = new int[]{3,2,3,1,2,4,5,5,6};
    int k = 4;
    System.out.println("该组数的第"+k+"大的是:"+getK(arr, k));
}
public static int getK(int[] nums,int k){
    PriorityQueue<Integer> pq = new PriorityQueue<>(k,(p1,p2)->p1-p2);  // 声明一个优先队列,设置比较规则,p1-p2,这是设置从小到大排列,构建小顶堆
    for(int i=0; i<k; i++){           // 先将前k个数放进队列
        pq.offer(nums[i]);
    }
    for(int i=k; i<nums.length; i++){ 
        if(nums[i] > pq.peek()){      // 之后的数如果比现在队头的元素大,就将队头元素出队,该数加入到队尾。
            pq.poll();				 // 由此一来,队列中最终只会存放该组数中最大的k个数,且对头是这些数中最小的,因此也就是										第K大的数
            pq.offer(nums[i]);
        }
    }
    return pq.peek();
}

// 输出 4

2. 求最大的前k个数，从大到小进行排序

// 由上一个题可以进行演进,上一题最后队列中只剩下最大的前k个数,输出即可
public static void main(String[] args) {
    int[] arr = new int[]{3,2,3,1,2,4,5,5,6};
    int k = 4;
    System.out.println("该组数最大的前"+k+"个数分别为:");
    int[] res = getK(arr, k);
    for (int re : res) {
        System.out.print(re+"  ");
    }
}
public static int[] getK(int[] nums,int k){
    PriorityQueue<Integer> pq = new PriorityQueue<>(k,(p1,p2)->p1-p2);
    for(int i=0; i<k; i++){
        pq.offer(nums[i]);
    }
    for(int i=k; i<nums.length; i++){
        if(nums[i] > pq.peek()){
            pq.poll();
            pq.offer(nums[i]);
        }
    }
    int[] res = new int[k];  
    for(int i=k-1; i>=0; i--){ // 此处需要注意的是,因为原来的队列中的元素是从小到大排序的,此处的数组倒序赋值。
        res[i] = pq.poll();
    }
    return res;
}

3. 求最小的第k个数

// 与1类似,不过此时就得用大顶堆
public static void main(String[] args) {
    int[] arr = new int[]{3,2,3,1,2,4,5,5,6};
    int k = 4;
    System.out.println(getK(arr, k));
}
public static int getK(int[] nums,int k){
    PriorityQueue<Integer> pq = new PriorityQueue<>(k,(p1,p2)->p2-p1); // 此时构建大顶堆,与前面相反
    for(int i=0; i<k; i++){
        pq.add(nums[i]);
    }

    for(int i=k; i<nums.length; i++){
        if(nums[i] < pq.peek()){ // 比队头小得元素才放到队列尾部
            pq.poll();
            pq.offer(nums[i]);
        }
    }
    return pq.peek();
}
// 输出 3

4. 求最小的k个数，从小到大排序，与2类似，不再赘述

public static void main(String[] args) {
    int[] arr = new int[]{3,2,3,1,2,4,5,5,6};
    int k = 4;
    int[] res = getK(arr, k);
    for (int re : res) {
        System.out.print(re+"  ");
    }

}
public static int[] getK(int[] nums,int k){
    PriorityQueue<Integer> pq = new PriorityQueue<>(k,(p1,p2)->p2-p1);
    for(int i=0; i<k; i++){
        pq.offer(nums[i]);
    }

    for(int i=k; i<nums.length; i++){
        if(nums[i] < pq.peek()){
            pq.poll();
            pq.offer(nums[i]);
        }
    }

    int[] res = new int[k];
    for(int i=k-1; i>=0; i--){
        res[i] = pq.poll();
    }
    return res;
}
// 输出 1  2  2  3  

5. 力扣347题

给你一个整数数组nums和一个整数k，请你返回其中出现频率前k高的元素。你可以按任意顺序返回答案。

大致思路：使用map来记录每个元素以及每个元素出现的次数，之后使用优先队列，因为题目要求返回出现频率最高的，所以需要使用小顶堆。

public static void main(String[] args) {
    int[] nums = {1,1,1,2,2,3};
    int k = 2;
    int[] res = getK(nums, k);
    for (int re : res) {
        System.out.print(re+"  ");
    }
}
public static int[] getK(int[] nums,int k) {
    Map<Integer,Integer> map = new HashMap<>();
    for (int num : nums) { // 记录每一个元素出现的次数,key为元素,value为元素出现的次数
        map.put(num,map.getOrDefault(num,0)+1);
    }
    PriorityQueue<int[]> pq = new PriorityQueue<>((p1,p2)->p1[1]-p2[1]);
    for(Map.Entry<Integer,Integer> entry:map.entrySet()){
        if(pq.size() < k){ 
            pq.offer(new int[]{entry.getKey(),entry.getValue()});
        }else{
            if(entry.getValue() > pq.peek()[1]){
                pq.poll();
                pq.offer(new int[]{entry.getKey(),entry.getValue()});
            }
        }
    }
    int[] res = new int[k];
    for (int i=k-1; i>=0; i--){
        res[i] = pq.poll()[0];
    }
    return res;
}
// 输出 1  2