代码随想录算法训练营第十三天：栈与队列- 239. 滑动窗口最大值、347.前 K 个高频元素

day13：栈与队列- 239. 滑动窗口最大值、347.前 K 个高频元素

LeetCode 239. 滑动窗口最大值

题目链接：

239. 滑动窗口最大值

文章讲解：

https://programmercarl.com/0239.%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E6%9C%80%E5%A4%A7%E5%80%BC.html

视频讲解：

https://www.bilibili.com/video/BV1XS4y1p7qj/

思路和解法：

也许会想到大顶堆，但是问题是这个窗口是移动的，而大顶堆每次只能弹出最大值，我们无法移除其他数值，这样就造成大顶堆维护的不是滑动窗口里面的数值了。所以不能用大顶堆。

单调队列

仔细分析，滑动窗口很像一个队列，向下一个窗口移动的时候，Pop掉最前面的元素，Push进一个新元素，队列中始终维护这个窗口里面的值，每次都有一个GetMaxValue方法获取当前队列里的最大值。但没有这种数据结构需要自己实现GetMaxValue。

所以可以自定义一个单调队列。单调队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的，也就是单调递减队列。

所以在设计的时候，需要注意以下方面：

队列中的元素从头到尾是按照递减顺序排列的。在添加新元素时，它会从队列尾部开始移除比新元素小的元素，然后将新元素添加到队列尾部，以保持队列的单调递减性质。

保持如上规则，每次窗口移动的时候，只要获取到队列的出口元素就可以返回当前窗口的最大值。

public class Solution {
    class myDequeue{
        private LinkedList<int> linkedList = new LinkedList<int>();

        public void Enqueue(int n){
            while(linkedList.Count > 0 && linkedList.Last.Value < n){
                linkedList.RemoveLast();
            }
            linkedList.AddLast(n);
        }

        public int Max(){
            return linkedList.First.Value;
        }

        public void Dequeue(int n){
            if(linkedList.First.Value == n){
                linkedList.RemoveFirst();
            }   
        }
    }

    myDequeue window = new myDequeue();
    List<int> res = new List<int>();
    
    public int[] MaxSlidingWindow(int[] nums, int k) {
        for(int i = 0; i < k; i++){
            window.Enqueue(nums[i]);
        }
        res.Add(window.Max());
        for(int i = k; i < nums.Length; i++){
            window.Dequeue(nums[i-k]);
            window.Enqueue(nums[i]);
            res.Add(window.Max());
        }

        return res.ToArray();
    }
}

LeetCode 347.前 K 个高频元素

题目链接：

347.前 K 个高频元素

文章讲解：

https://programmercarl.com/0347.%E5%89%8DK%E4%B8%AA%E9%AB%98%E9%A2%91%E5%85%83%E7%B4%A0.html

视频讲解：

https://www.bilibili.com/video/BV1Xg41167Lz/

思路和解法：

两个难点

• 如何求数组里面每个元素的频率
• 如何对这个频率进行排序并求前k个高频元素

如果使用map的话，key存每个元素，value存每个元素出现的次数，然后排序，输出前k个元素。排序按快排的时间复杂度算是nlogn。对于本题，没必要对所有元素进行排序，只需要维护k个有序的集合就可以了，所以可以考虑堆（大顶堆/小顶堆）。

堆

用堆去遍历map中的所有元素，但是堆里面只维持k个元素，把map中所有元素遍历完之后，堆里面的k个元素就是要求的前k个高频元素。

**不采用大顶堆的原因：**堆中维护了固定k个元素，如果向堆中加入一个元素，即push进来一个元素，那么就要pop一个元素，在堆里，pop是从堆顶进行操作的，如果采用大顶堆的话，就会把堆顶的值给弹出去，也就是把最大元素给弹出去了，所以采用小顶堆。

采用小顶堆，在堆k个元素进行维护的时候，是不断地把堆顶（也就是最小的元素）给弹出去，最终留下来的就是最大的那些元素，也就是统计频率

步骤：

1. 创建一个字典来存储每个元素的频率，其中键是元素，值是频率。
2. 遍历整数数组nums，统计每个元素的频率并存储在字典中。
3. 创建一个小顶堆（优先队列），将字典中的元素按照频率放入堆中，同时保持堆的大小不超过k，即只保留频率前k高的元素。
4. 遍历完整个数组后，堆中将包含频率前k高的元素。
5. 从堆中依次弹出这些元素并返回，它们可以按任意顺序返回。

public class Solution {
    public int[] TopKFrequent(int[] nums, int k) {
        //哈希表
        Dictionary<int,int> dic = new();
        for(int i = 0; i < nums.Length; i++){
            if(dic.ContainsKey(nums[i])){
                dic[nums[i]]++;
            }else{
                dic.Add(nums[i], 1);
            }
        }
        //优先队列（小顶堆）从小到大排列
        PriorityQueue<int,int> minHeap = new();
        foreach(var num in dic){
            minHeap.Enqueue(num.Key, num.Value);
            if(minHeap.Count > k){
                minHeap.Dequeue();
            }
        }
        
        //数组倒装
        int[] res = new int[k];
        for(int i = k - 1; i >= 0; i--){
            res[i] = minHeap.Dequeue();
        }
        return res;
    }
}