代码训练营day13｜栈与队列part03

 239. 滑动窗口最大值

 具体可以看代码随想录文章：代码随想录

思路：写好了滑动窗口框架，想到了暴力算法，想到了priorityqueue，因为感觉不太对，所以没写下去

代码问题：

最后结果由linked list转回数组会超时

滑动窗口模版：把窗口视作左闭右开

实现单调栈的时候代码习惯要好：删除/获取栈内元素前都要检查是否非空（即使题目内逻辑不会涉嫌这种风险）

总结：需要自己实现单调队列，不需要维护所有值，只需要维护可能成为最大值的所有元素

不需要维护（比加入的值更小的）元素，因为在该（更大，这次加入的）元素弹出前，在（更大，这次加入的）元素前面的更小元素都不需要被考虑

单调队列push思路：把队列前面比加入的值更小的值全部都删除

pop思路：如果是当前单调栈的最大值，就把栈顶的最大值pop掉，在最大值前面的比最大值小的值，在最大值加入的时候，就已经pop出去了，不需要再做任何操作

不能使用优先级队列（最大堆），优先级队列会使窗口中数值顺序改变，pop的时候并不是你想要pop的元素/需要更多的时间复杂度来专门删掉优先级队列里的元素（找到并删除）：问题是这个窗口是移动的，而大顶堆每次只能弹出最大值，我们无法移除其他数值，这样就造成大顶堆维护的不是滑动窗口里面的数值了。所以不能用大顶堆。

时间复杂度O(n)：（在单调队列的实现中：所有元素最多被push pop一次，还是O(n)量级的）

空间复杂度O(k)

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int left = 0, right = 0;

        int[] maxW = new int[nums.length-k+1];
        MonoQueue window = new MonoQueue();
        while(right<nums.length){

            window.push(nums[right]);
            right++;
            while(left<right&&right-left>=k){
                maxW[right-k]=window.top();
                window.pop(nums[left]);
                left++;
            }

        }

        

        return maxW;
    }
    class MonoQueue{
        LinkedList<Integer> queue;

        public MonoQueue(){
            queue = new LinkedList<>();
        }
        public void push(int n){
            while(!queue.isEmpty()&&queue.getLast()<n){
                queue.removeLast();
            }
            queue.addLast(n);
        }
        public void pop(int n){
            if(!queue.isEmpty()&&n==queue.getFirst())queue.removeFirst();
        }
        public int top(){
            return queue.getFirst();
        }
    }
}

347.前 K 个高频元素

思路：把频率现存出来，再用优先级队列排序

总结：只需要维护大小为k的小顶堆/priorityqueue，队列/堆满了的时候pop一个push一个

Java：如何对hashmap申明优先级队列 （语言怎么写）

Map.Entry使用办法：JAVA学习笔记——Map.Entry_java map.entry-CSDN博客

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int num:nums){
            map.put(num,map.getOrDefault(num,0)+1);
        }
        int[] res = new int[k];
        PriorityQueue<int[]> pq = new PriorityQueue<>((a,b)->a[1]-b[1]);
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            if(pq.size()<k){
                pq.add(new int[]{entry.getKey(),entry.getValue()});
            }else{
                
                pq.add(new int[]{entry.getKey(),entry.getValue()});
                pq.poll();
            }
        }
        for(int i=k-1;i>=0;i--){
            res[i]=pq.poll()[0];
        }

        return res;
    }
}

要么先加入，排序完之后再删除，其实是维护k+1大小的优先级队列

要么先判断加入的值是否比最小值大：

如果比最小值大，可以先删除最小值，再加入该值

如果比最小值小，可以直接不加入

如果没有判断条件：可能删掉堆顶更大的值，把相对较小的值加入其中，e.g

堆顶：5，要加入的值1

应该是留5放弃1，但是没有判断条件会直接删除5，然后把1加入

if(entry.getValue()>pq.peek()[1]){//当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
    pq.poll();//弹出队头(小顶堆的根结点),即把堆里出现次数最少的那个删除,留下的就是出现次数多的了
    pq.add(new int[]{entry.getKey(),entry.getValue()});
}