Java优先队列API用法

        PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2; //o1 - o2 为小顶堆，poll出来的是最小的，反之为大顶堆poll出来的是最大的
            }
        });
        // PriorityQueue queue = new PriorityQueue<>((o1, o2) -> o1 - o2);//简写
        queue.add(2);
        queue.add(1);
        queue.add(3);
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());

相关题目

一手顺子

题目：Alice 手中有一把牌，她想要重新排列这些牌，分成若干组，使每一组的牌数都是 groupSize ，并且由 groupSize 张连续的牌组成。能排成这样返回true，不能返回false
⭐

输入：hand = [1,2,3,6,2,3,4,7,8], groupSize = 3
输出：true
解释：Alice 手中的牌可以被重新排列为 [1,2,3]，[2,3,4]，[6,7,8]。

思路：把牌全放入优先队列，每次取出最小的牌再移除和和这个最小的牌组成顺子的元素，发现移除失败说明找不到这组顺子，返回false
java代码 【模拟/优先队列力扣题解】

class Solution {
    public boolean isNStraightHand(int[] hand, int groupSize) {
        if(hand.length % groupSize != 0) return false;
        //从最小的数开始找对子，找到就把牌丢出来，一直找
        PriorityQueue<Integer> queue = new PriorityQueue<>();
        for (int i : hand) {
            queue.add(i);
        }
        while (!queue.isEmpty()) {
            int min  = queue.poll();
            for (int i = 1; i < groupSize; i++) {
                boolean remove = queue.remove(min + i);
                if(!remove) {
                    return false;
                }
            }
        }
        return true;
    }
}

数据流中第K大元素

⭐

题目： 设计一个找到数据流中第 k 大元素的类（class）。注意是排序后的第 k 大元素，不是第 k 个不同的元素。
请实现 KthLargest 类：
KthLargest(int k, int[] nums) 使用整数 k 和整数流 nums 初始化对象。
int add(int val) 将 val 插入数据流 nums 后，返回当前数据流中第 k 大的元素。

题目分析： 每次加入一个新的数以后，都返回 第 K 大的元素， （例如：1，2，3 第1大就是返回3）
思路：

1. 初始化维护一个小顶堆（队列头部是较小的数）， 堆的容量控制为k，
2. add()数据时，如果queue大小不足k ，先给queue内添加元素到k。
3. 如果queue达到k则大于堆顶就加入堆，然后移除堆顶， 如果小于堆顶，舍弃。 这样堆顶一直都是第K大的数。

代码实现：

class KthLargest {
    PriorityQueue<Integer> queue = new PriorityQueue<>();
    final int k;
    public KthLargest(int k, int[] nums) {
        for(int i : nums) queue.add(i);
        this.k = k;
        //注意这里是while，执行完这句话，queue中有k 或 k-1个数字（题目数据保证，在查找第 k 大元素时，数组中至少有 k 个元素）
        while(queue.size() > k) queue.poll();
    }
    public int add(int val) {
        //当queue中只要k - 1 个元素时，需要将当前值加入queue
        if(queue.size() < k) queue.add(val);
        //否则就是替换元素，加进去一个，退出来一个
        else if(val > queue.peek()) {
            queue.add(val);
            queue.poll();
        }
        return queue.peek();
    }
}

找到和最大的长度为 K 的子序列

⭐

题目： 给你一个整数数组 nums 和一个整数 k 。你需要找到 nums 中长度为 k 的 子序列 ，且这个子序列的 和最大 。返回 任意 一个长度为 k 的整数子序列。
子序列 定义为从一个数组里删除一些元素后，不改变剩下元素的顺序得到的数组。


输入：nums = [2,1,3,3], k = 2
输出：[3,3]

题目分析：和最大的子序列，最大的和就是数组中前k大的数字的和， 题目要求返回子序列，相当于返回这些前k大数字按数组的顺序排列的数组。
思路1：复制数组 + 数组排序 + hashMap ，数组排序前k大的数字， hashMap存前k大数字与出现次数，然后遍历原数组，等于hashMap中的就取出来。代码
思路2：

1. 维护一个大小为k的小顶堆，小顶堆存放数字与对应索引，按数字排序。
2. 先把数字放入队列，使队列大小达到k， 然后小于堆顶的跳过，大于堆顶的放入队列，再弹出堆顶。
3. 此时队列中即为前k大数字及其索引，我们取出索引排序后按索引对应的值放入返回数组中

代码实现：

class Solution {
    public int[] maxSubsequence(int[] nums, int k) {
        PriorityQueue<int[]> queue = new PriorityQueue<>((o1, o2) -> o1[1] - o2[1]);
        //维护大小为k 的优先队列，队列中存放索引与数值，队列按数值排序。
        for(int i = 0; i < nums.length; i++) {
            if(queue.size() < k) {
               queue.offer(new int[]{i, nums[i]});
           }else if(nums[i] > queue.peek()[1]) {
               queue.offer(new int[]{i, nums[i]});
               queue.poll();
           }
        }
        //取出索引
        int[] ret =new int[k];
        int index = 0;
        while(!queue.isEmpty()) {
            ret[index++] = queue.poll()[0];
        }
        //索引排序
        Arrays.sort(ret);
        //按顺序将数组放入返回数组
        for(int i = 0; i < k; i++) {
            ret[i] = nums[ret[i]];
        }
        return ret;
    }
}

矩阵中战斗力最弱的 K 行

题目：给你一个大小为 m * n 的矩阵 mat，矩阵由若干军人和平民组成，分别用 1 和 0 表示。返回矩阵中战斗力最弱的 k 行的索引，按从最弱到最强排序。
如果第 i 行的军人数量少于第 j 行，或者两行军人数量相同但 i 小于 j，那么我们认为第 i 行的战斗力比第 j 行弱。
军人 总是 排在一行中的靠前位置，也就是说 1 总是出现在 0 之前。

输入示例：

输入：mat =
[[1,1,0,0,0],
[1,1,1,1,0],
[1,0,0,0,0],
[1,1,0,0,0],
[1,1,1,1,1]],
k = 3
输出：[2,0,3]

题目分析： 战斗力最弱的前k个，即矩阵中和最小的前k行。
思路：维护一个大顶堆，按照每行的和排序，和大的排前面，如果和相同，i大的排前面

class Solution {
    public int[] kWeakestRows(int[][] mat, int k) {
        // queue 中保存 i 和 sum
        PriorityQueue<int[]> queue = new PriorityQueue<>((o1, o2)-> {
            if(o2[1] == o1[1]) return o2[0] - o1[0]; //如果sum相等就按i降序
            else return o2[1] - o1[1];
        });

        for(int i = 0; i < mat.length; i++) {
            int[] tem = mat[i];
            int sum = getSum(tem);
            if(queue.size() < k) {
                queue.add(new int[]{i,sum});
            }else {
                //由于 是 i 从小到大遍历的，所有如果栈顶和是相同的，那么栈里的i一定是较小的，满足要求。
                if(sum < queue.peek()[1]) {
                    queue.add(new int[]{i, sum});
                    queue.poll();
                }
            }
        }
        //栈中元素是从大到小的，前k小元素，所以要倒着放入返回数组
        int[] ret = new int[k];
        int index = k - 1;
        while(!queue.isEmpty()) {
            ret[index--] = queue.poll()[0];
        }
        return ret;
    }

    public int getSum(int[] a) {
        int sum = 0;
        for(int i = 0; i < a.length; i++) sum += a[i];
        return sum;
    }
}

吃苹果的最大数目

⭐⭐
精炼题目： apples[i]代表第i天长多少个苹果；days[i]代表第i天长的苹果多少天后腐烂，即腐烂日期为days[i] + i,每天最多吃一个苹果，求最多吃多少苹果。

思路： 用优先队列，存储苹果数量及腐烂日期，每天取最烂的苹果吃【腐烂日期最小，且腐烂日期 > 当前日期】

注意：
1.在小于n天【数组长度】那段时间，先去收果子，然后取果子看有没有果子吃，有就吃一个，没有就不吃。
2.在n天过后，直接计算出未来几天有果子吃。

class Solution {
public int eatenApples(int[] apples, int[] days) {
        PriorityQueue<int[]> queue = new PriorityQueue<>((o1, o2) -> o1[1] - o2[1]);
        int n = apples.length;
        int ret = 0;
        int curDay = 0;
        while (curDay < n) {
            if(apples[curDay] !=0)
            queue.add(new int[]{apples[curDay], curDay + days[curDay]});
            while (queue.size() > 0) {
                if (queue.peek()[1] > curDay) {
                    ret++;
                    if(--queue.peek()[0] == 0) {
                        queue.poll();
                    }
                    break;
                }else {queue.poll();}
            }
            curDay++;
        }
        while (queue.size() > 0) {
            int[] poll = queue.poll();
            if (poll[1] > curDay){
                int tem = Math.min(poll[1] - curDay, poll[0]);
                ret += tem;
                curDay += tem;
            }
        }
        return ret;
    }
}

练习题