代码随想录算法训练营day13｜239. 滑动窗口最大值，347.前 K 个高频元素，总结

扭一扭.

已于 2022-12-06 08:41:31 修改

阅读量139

点赞数

文章标签：算法 leetcode 数据结构

于 2022-11-08 00:25:41 首次发布

本文链接：https://blog.csdn.net/weixin_52121600/article/details/127728814

版权

239. 滑动窗口最大值

力扣

思路：

1. 【单调队列】单调递减，使队列出口处永远是最大值：每加入一个元素，移除掉队列中所有比它小的元素。

2. poll(value): 如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素。

2. push(value): 如果push的元素value大于入口元素的数值，那么就弹出队列入口的元素，直到push元素的数值小于等于队列入口元素的数值。

3. 每次返回队列头元素到结果数组中。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length==1){
            return nums;
        }
        int len = nums.length-k+1;
        int[] res = new int[len];//存放结果的数组
        int num = 0;
        MyQueue my = new MyQueue();
        for(int i = 0;i<k;i++){//将前k个元素放入单调队列
            my.add(nums[i]);
        }
        res[num++] = my.peek();
        for(int i=k;i<nums.length;i++){
            my.poll(nums[i-k]);
            my.add(nums[i]);
            res[num++] = my.peek();
        }
        return res;
    }
    class MyQueue{
        Deque<Integer> deque = new LinkedList<>();
        void poll(int val){
            if(!deque.isEmpty() && val==deque.peek()){
                deque.poll();
            }
        }
        void add(int val){
            while(!deque.isEmpty() && val>deque.getLast()){
                deque.removeLast();
            }
            deque.add(val);
        }
        int peek(){
            return deque.peek();
        }
    }
}

其他思路：

【利用双端队列手动实现单调队列】：用一个单调队列来存储对应的下标。每当窗口滑动时，取队列头部指针对应的值放入结果集。

offer：在成功执行操作的前提下，可以向队列末端添加一个元素；当操作不成功时（列队已满），返回false。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        ArrayDeque<Integer> deque = new ArrayDeque<>();
        int n = nums.length;
        int[] res = new int[n-k+1];
        int idx = 0;
        for(int i = 0; i < n; i++){
            //i为nums下标;要在[i - k + 1, i] 中选到最大值，需要保证两点
            //1.队列头结点在[i - k + 1, i]范围内，不符合则要弹出
            while(!deque.isEmpty() && deque.peek() < i - k + 1){
                deque.poll();
            }
            //2.【单调队列】保证每次放进去的数字要比末尾元素小，否则弹出队列元素
            while(!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }
            deque.offer(i);
            //当i增长到符合第一个k范围的时候，每滑动一步，就将队列头节点放入结果
            if(i >= k - 1){
                res[idx++] = nums[deque.peek()];
            }
        }
        return res;
    }
}

347.前 K 个高频元素

力扣

思路：

1. 用Map统计元素出现频率

2. 使用【优先级队列】对元素进行排序：用小顶堆，每次将小顶堆最小的元素弹出，最后积累的就是前k个最大元素（即高频元素）。

3. Comparator接口：返回负数，形参中第一个参数排在前面；返回正数，形参中第一个参数排在后面。对于堆（使用PrioritQueue实现）：从队头到队尾从小到大排，就是小顶堆；从队头到队尾从大到小排，就是大顶堆。

PriorityQueue详解见：https://blog.csdn.net/hellokitty136/article/details/105831884/

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int n:nums){
            map.put(n,map.getOrDefault(n,0)+1);
        }
        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(p -> p[1]));
        for(Map.Entry<Integer,Integer> en:map.entrySet()){//小顶堆只需要维持k个元素有序
            if(pq.size()<k){//小顶堆元素少于k个时直接加
                pq.add(new int[]{en.getKey(),en.getValue()});
            }else if(en.getValue()>pq.peek()[1]){//当前元素出现次数大于小顶堆根节点
                pq.poll();//弹出根节点
                pq.add(new int[]{en.getKey(),en.getValue()});
            }
        }
        int[] res = new int[k];
        for(int i=k-1;i>=0;i--){
            res[i] = pq.poll()[0];
        }
        return res;
    }
}