day13 第五章 栈与队列part03

239. 滑动窗口最大值

力扣题目链接(opens new window)

给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回滑动窗口中的最大值。

进阶：

你能在线性时间复杂度内解决此题吗？

提示：

• 1 <= nums.length <= 10^5
• -10^4 <= nums[i] <= 10^4
• 1 <= k <= nums.length

解答: 这个题较为复杂一些,用自己的队列来解决会更方便,总的来说,核心思路就是在进入队列的时候,把队列中比自己小的数字全部抛出,这样就保证队列头部的数字始终是最大值,所以每次返回的都是最大值.

class Solution {
    class MyQue{
        Deque<Integer> que = new LinkedList<>();
        private void popFront(int num){
            if(!que.isEmpty() && num == que.peek()){
                que.poll();
            }
        }

        private void pushBack(int num){
            while(!que.isEmpty() && num > que.getLast()){
                que.removeLast();
             }
            que.add(num);
        }

        private int getMaxValue(){
            return que.peek();
        }
    }
    public int[] maxSlidingWindow(int[] nums, int k) {
        MyQue que = new MyQue();
        for(int i = 0; i < k; i++){
            que.pushBack(nums[i]);
        }
        int len = nums.length;
        int[] maxValue = new int[len - k + 1];
        maxValue[0] = que.getMaxValue();
        int count = 1;
        for(int i = k; i < len; i++){
            //滑动窗口移除最顶端的元素,并判断下一个元素是否进入队列
            que.popFront(nums[i - k]);
            //滑动窗口加入下一个元素
            que.pushBack(nums[i]);
            //将队列的第一个元素,也就是最大的元素放入数组
            maxValue[count++] = que.getMaxValue();
        }
        return maxValue;
    }

    
}

347.前 K 个高频元素

力扣题目链接(opens new window)

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

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

示例 2:

• 输入: nums = [1], k = 1
• 输出: [1]

提示：

• 你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
• 你的算法的时间复杂度必须优于 $O(n \log n)$ , n 是数组的大小。
• 题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
• 你可以按任意顺序返回答案。

解答: 这个题比较复杂,要用小顶堆或者大顶堆来实现,这里是用小顶堆实现的,注意如何写comparable的lamda函数.还有怎么运用map方法和map.entry方法以及怎么直接把数组的数快速取出来.

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        //这是一个基于小顶堆实现的方法
        //用map来记录一下每个数出现的次数
        Map<Integer,Integer> map = new HashMap<>();
        for(int n : nums){
            map.put(n,map.getOrDefault(n,0)+1);//如果存入过就+1,第一次遇到就新建一个0;
        }
        //然后定义一个优先排序序列
        PriorityQueue<int[]> que = new PriorityQueue<>((pair1,pair2)->pair1[1]-pair2[1]);
        //上面这个匿名函数定义了comparable接口,现在是一个从小到大排序的小顶堆
        //然后把数从map中输入到堆中比较
        for(Map.Entry<Integer,Integer> entry: map.entrySet()){
            //维持顶端堆只需要k个元素
            if(que.size() < k){
                que.add(new int[]{entry.getKey(),entry.getValue()});
            }
            else{//如果输入堆的元素大于堆顶端的最小值,则弹出堆顶,输入这个值到堆内
                if(que.peek()[1] < entry.getValue()){
                    que.poll();
                    que.add(new int[]{entry.getKey(),entry.getValue()});
                }
            }
        }
        //将序列值输入到新数组中去
        int[] res = new int[k];
        for(int i = k-1; i >= 0 ; i--){
            res[i] = que.poll()[0];
        }
        return res;
    }
}