代码随想录算法训练营第12天 | 第五章栈与队列part02

monoki

关注

最新推荐文章于 2026-08-15 11:04:49 发布 · 1k 阅读

原创 ·

本内容遵循 CC 4.0 BY-SA 版权协议

· GEO检测

文章目录

今日记录
150.逆波兰表达式求值
239.滑动窗口最大值
347.前K个高频元素
- 思路
- - 优先级队列 priority_queue
总结

今日记录

150.逆波兰表达式求值

Leetcode链接

给你一个字符串数组 tokens ，表示一个根据逆波兰表示法表示的算术表达式。
请你计算该表达式。返回一个表示表达式值的整数。
注意：
有效的算符为 ‘+’、‘-’、‘*’ 和 ‘/’ 。
每个操作数（运算对象）都可以是一个整数或者另一个表达式。
两个整数之间的除法总是向零截断。
表达式中不含除零运算。
输入是一个根据逆波兰表示法表示的算术表达式。
答案及所有中间计算结果可以用 32 位整数表示。

逆波兰表达式：是一种后缀表达式（运算符写在后面）用栈来实现：遇到数字则入栈；遇到运算符则取出栈顶的两个元素进行运算再压入栈中；

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st;
        for (int i = 0; i < tokens.size(); i++) {
            if (tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" ||
                tokens[i] == "/") {
                long long num1 = st.top();
                st.pop();
                long long num2 = st.top();
                st.pop();
                if (tokens[i] == "+")
                    st.push(num2 + num1);
                if (tokens[i] == "-")
                    st.push(num2 - num1);
                if (tokens[i] == "*")
                    st.push(num2 * num1);
                if (tokens[i] == "/")
                    st.push(num2 / num1);
            } else {
                st.push(stoll(tokens[i])); // 将字符串str转成 long long 整数
            }
        }
        int result = st.top();
        st.pop();
        return result;
    }
};

239.滑动窗口最大值

Leetcode链接

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值。

使用队列，将窗口里的元素放入，随着窗口移动，队列加入新元素，前面的元素也出队。
queue que;
窗口移动，先que.pop()移除元素，que.push()加入新元素, que.front()

class Solution {
private:
    class Myqueue {
    public:
        deque<int> que; // 一个双向队列
        // pop函数实现：因为比队列出口的元素已经在push函数里被弹出了，所以除非新加入元素等于队列出口元素，否则不用做任何操作
        void pop(int value) {
            if (!que.empty() && value == que.front()) { // 返回队列头部的元素
                que.pop_front(); // 移除队列前端的元素
            }
        }
        // push函数实现：当新加入的元素比队列入口元素大，将入口元素一个一个弹出直到比入口元素小，保证了弹出顺序是从小到大（如果此时新加入的元素比队列出口的元素还大，一直弹出到队列出口的元素也被弹出）
        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) {
        Myqueue que;
        vector<int> result;
        for (int i = 0; i < k; i++) { // 滑动窗口值为k，先将前k个值放入
            que.push(nums[i]);
        }
        result.push_back(
            que.front()); // result将前k个最大值记录:向容器末尾添加值
        for (int i = k; i < nums.size(); i++) {
            que.pop(nums[i - k]); // 移除前面的值
            que.push(nums[i]);
            result.push_back(que.front());
        }
        return result;
    }
};

347.前K个高频元素

Leetcode链接

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按任意顺序返回答案。

思路

这道题目主要涉及到如下三块内容：
1.要统计元素出现频率 —— map可以实现
2.对频率排序 —— 优先级队列 priority_queue
3.找出前K个高频元素

优先级队列 priority_queue

就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。
而且优先级队列内部元素是自动依照元素的权值排列。

什么是堆呢？
堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。
大顶堆（堆头是最大元素），小顶堆（堆头是最小元素），如果懒得自己实现的话，就直接用priority_queue（优先级队列）就可以了，底层实现都是一样的，从小到大排就是小顶堆，从大到小排就是大顶堆。

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

定义：

priority_queue< type, container, function>；

这三个参数，后面两个可以省略，第一个不可以。其中：
type：数据类型；
container：实现优先队列的底层容器，必须是可随机访问的容器，例如vector、deque，而不能使用list；
function：元素之间的比较方式；
在STL中，默认情况下（不加后面两个参数）是以vector为容器，以 operator< 为比较方式，所以在只使用第一个参数时，优先队列默认是一个最大堆，每次输出的堆顶元素是此时堆中的最大元素。

class Solution {
public:
    // 小顶堆
    class mycomparison {
    public:
        //()符号重载
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        // 要统计元素出现频率
        unordered_map<int, int> map; // map<nums[i],对应出现的次数>
        for (int i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }

        // 对频率排序
        // 定义一个小顶堆，大小为k
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;

        // 用固定大小为k的小顶堆，扫面所有频率的数值
        for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
            pri_que.push(*it);
            if (pri_que.size() > k) { // 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                pri_que.pop();
            }
        }

        // 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;

    }
};