代码随想录算法训练营第十二天|● 239. 滑动窗口最大值 ● 347.前 K 个高频元素 ● 总结

deque函数

创建的deque

添加元素

deque.addFirst();
deque.addLast();
deque.offerFirst();
deque.offerLast();

移除元素

String e=deque.removeFirst();
String e=deque.removeLast();
String e=deque.pollFirst();
String e=deque.pollLast();

获取元素

String firste=deque.element();
String firste=deque.peek();
String firste=deque.peekFirst();
String laste=deque.peekLast();

最小栈

题目

思路：

代码：

class MinStack {
    private Stack<Integer> stack;
    private Stack<Integer> min_stack;
    public MinStack() {
        stack = new Stack<>();
        min_stack = new Stack<>();
    }
    
    public void push(int val) {
        stack.push(val);
        if(min_stack.isEmpty()||min_stack.peek()>=val){
            min_stack.push(val);
        }
    }
    
    public void pop() {
        int num=stack.pop();
        if(min_stack.peek()==num){
        // if(stack.pop()!=min_stack.peek())
            min_stack.pop();
        }
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        return min_stack.peek();
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(val);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

239. 滑动窗口最大值

思路：

找一个最小栈储存

1. pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
2. push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止

核心思路：

代码：

先判断是否要pop 再push。push的时候需要把不应该要的都弹出

在这里插入代码片class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        Deque<Integer> deque =new LinkedList<>();
        int[] res = new int[nums.length-k+1];
        for(int j=0,i=1-k;j<nums.length;i++,j++){
            // 删除 deque 中对应的 nums[i-1]// 也就是最大值
            if(i>0&&deque.peekFirst()==nums[i-1]){
                deque.removeFirst();
            }
            // 2.既然是单调，就要保证每次放进去的数字要比末尾的都大，否则也弹出
            // while(!deque.isEmpty()&&nums[j]>=deque.peekLast()){
            while(!deque.isEmpty()&&nums[j]>deque.peekLast()){
                deque.removeLast();
            }
            deque.add(nums[j]);
            if(i>=0){
                res[i]=deque.peekFirst();
            }
        }
        return res;
    }
}

347. 前 K 个高频元素

思路：

这道题目主要涉及到如下三块内容：

1. 要统计元素出现频率
2. 对频率排序
3. 找出前K个高频元素

首先统计元素出现的频率，这一类的问题可以使用map来进行统计。

然后是对频率进行排序，这里我们可以使用一种 容器适配器就是优先级队列。

什么是优先级队列呢？

其实就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。

而且优先级队列内部元素是自动依照元素的权值排列。那么它是如何有序排列的呢？

缺省情况下priority_queue利用max-heap（大顶堆）完成对元素的排序，这个大顶堆是以vector为表现形式的complete binary tree（完全二叉树）。
什么是堆呢？

堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。

所以大家经常说的大顶堆（堆头是最大元素），小顶堆（堆头是最小元素），如果懒得自己实现的话，就直接用priority_queue（优先级队列）就可以了，底层实现都是一样的，从小到大排就是小顶堆，从大到小排就是大顶堆。

本题我们就要使用优先级队列来对部分频率进行排序。

为什么不用快排呢， 使用快排要将map转换为vector的结构，然后对整个数组进行排序， 而这种场景下，我们其实只需要维护k个有序的序列就可以了，所以使用优先级队列是最优的。
此时要思考一下，是使用小顶堆呢，还是大顶堆？

有的同学一想，题目要求前 K 个高频元素，那么果断用大顶堆啊。

那么问题来了，定义一个大小为k的大顶堆，在每次移动更新大顶堆的时候，每次弹出都把最大的元素弹出去了，那么怎么保留下来前K个高频元素呢。

而且使用大顶堆就要把所有元素都进行排序，那能不能只排序k个元素呢？

所以我们要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。

代码：

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        //  优先级队列，为了避免复杂api操作，pq储存数组
        //出现次数按从队头到队尾的顺序是从小到大排,出现次数最低的在队头(相当于小顶堆)
        // lambda表达式设置优先级队列从大到小储存 o1-o2为从小到大，o2-o1反之
        // 可以理解为按照一个数组的第二维升序 如a=[x,y]根据a和b的y的大小去排序，小的放在队列前
        PriorityQueue<int[]> pq=new PriorityQueue<>((o1,o2)->o1[1]-o2[1]);
        int[] res=new int[k]; //答案数组为k个元素
        Map<Integer,Integer>map=new HashMap<>(); //记录元素出现次数
        for(int num:nums){
            map.put(num,map.getOrDefault(num,0)+1);
        }
        for(var x:map.entrySet()){//entryset获取k-v set集合
            //将kv转化为数值
            int[] tmp=new int[2];
            tmp[0]=x.getKey();
            tmp[1]=x.getValue();
            pq.add(tmp);
            //只保留优先队列的最后k个，只要超出了k我就将最小的弹出，剩余的k个就是答案
            if(pq.size()>k){
                pq.poll();
            }
        }
        for(int i=0;i<k;i++){
            res[i]=pq.poll()[0];//获取优先队列里的元素
        }
        return res;
    }
}

总结