代码随想录训练营Day12|347.前k个高频元素、239.滑动窗口最大值

小胡爱喝水

已于 2023-10-11 00:35:11 修改

阅读量47

点赞数

分类专栏： LeetCode刷题文章标签： leetcode 算法数据结构

于 2023-05-01 19:47:14 首次发布

本文链接：https://blog.csdn.net/qq_40837128/article/details/130458251

版权

LeetCode刷题专栏收录该内容

39 篇文章 0 订阅

订阅专栏

文章介绍了单调队列和单调栈的数据结构及其在解决LeetCode问题中的应用，如用于求解滑动窗口最大值和找出数组中的前k个高频元素。单调队列用于保证元素单调递增或递减，而单调栈同样保持单调性。在滑动窗口最大值问题中，单调队列能有效处理窗口内的元素更新。对于找出高频元素，文章提到了哈希映射和优先队列（堆）两种方法。

摘要由CSDN通过智能技术生成

单调队列和单调栈

单调队列

template<typename T>
class MonotonicQueue {
private:
    deque<T> data;
public:
    void push(const T& value) {
        while (!data.empty() && data.back() < value) {
            data.pop_back();
        }
        data.push_back(value);
    }

    void pop(const T& value) {
        if (!data.empty() && data.front() == value) {
            data.pop_front();
        }
    }

    T max() const {
        return data.front();
    }
};

单调栈

template<typename T>
class MonotonicQueue {
private:
    deque<T> data;
public:
    void push(const T& value) {
        while (!data.empty() && data.back() < value) {
            data.pop_back();
        }
        data.push_back(value);
    }

    void pop(const T& value) {
        if (!data.empty() && data.front() == value) {
            data.pop_front();
        }
    }

    T max() const {
        return data.front();
    }
};

leetcode239：滑动窗口最大值

思路：单调队列，保证当前的队列里的元素是单调递减了

class Solution {
private:
    class Mydeque{
        public:
            deque<int> que;
            void pop(int value){
                if(!que.empty() && value == que.front()){
                    que.pop_front();
                }
            }
            // 这里已经实现好了，会保证添加的元素是单调递减的
            void push(int value){
                while(!que.empty() && value > que.back()){
                    que.pop_back();
                }
                que.push_back(value);
            }

            int front(){
                return que.front();
            }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        Mydeque que;
        vector<int> ans;
        for(int i=0;i<k;i++){
            que.push(nums[i]);
        }
        ans.push_back(que.front());
        for(int i=k;i<nums.size();i++){
            que.pop(nums[i-k]);// 删除左侧超出窗口的元素
            que.push(nums[i]);
            ans.push_back(que.front());
        }
        return ans;
    }
};

LeetCode347：前k个高频元素

这里用的是Hash来做的，复杂度较高。
最好的方法是用堆来做，在复习完树之后，回顾本题。

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<Map.Entry<Integer, Integer>> queue = new PriorityQueue<>((e1, e2) -> e2.getValue() - e1.getValue());
        queue.addAll(map.entrySet());
        int[] ans = new int[k];
        for (int i = 0; i < k && !queue.isEmpty(); ++i){
            ans[i] = queue.poll().getKey();
        }
        return ans;
    }
}