刷题了：150. 逆波兰表达式求值 |239. 滑动窗口最大值 |347.前 K 个高频元素

150. 逆波兰表达式求值

题目链接:https://leetcode.cn/problems/evaluate-reverse-polish-notation/description/
文章讲解:https://programmercarl.com/0150.%E9%80%86%E6%B3%A2%E5%85%B0%E8%A1%A8%E8%BE%BE%E5%BC%8F%E6%B1%82%E5%80%BC.html
视频讲解:https://www.bilibili.com/video/BV1kd4y1o7on/?spm_id_from=333.788&vd_source=e70917aa6392827d1ccc8d85e19e8375
介绍：
逆波兰表达式（Reverse Polish Notation，RPN），又称后缀表达式，是一种特殊的数学表达式表示方法。这种方法由波兰逻辑学家J・卢卡西维兹（J・Lukasewicz）于1929年首先提出。逆波兰表达式的特点是将运算符写在操作数（即运算量）的后面，并且整个表达式不包含括号，所有的计算按照运算符出现的顺序严格从左向右进行，不再考虑运算符的优先规则。
实现情况：
1、栈数据类型需要使用long long
2、弹出为什么这样操作？

long long num1 = st.top();//该方法返回栈顶元素的引用（但实际上在 C++ 中，由于栈中的元素是值类型，这里返回的是栈顶元素的拷贝）。然后，这个返回值（即栈顶元素的值）被赋值给变量 num1
 st.pop();// pop() 方法，该方法从栈中移除栈顶元素

3、遍历数组的方法

 for (string& token : tokens) 
 for (const string& token : tokens)
 for (int i = 0; i < tokens.size(); i++)

4、直接将字符串转换为 long long

st.push(stoll(token));

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st;

        for (const string& token : tokens) {
            if (token == "+" || token == "-" || token == "*" || token == "/") {
                long long num1 = st.top();
                st.pop();
                long long num2 = st.top();
                st.pop();
                if (token == "+")
                    st.push(num2 + num1);
                if (token == "-")
                    st.push(num2 - num1);
                if (token == "*")
                    st.push(num2 * num1);
                if (token == "/")
                    st.push(num2 / num1);
            } else {
                st.push(stoll(token));
            }
        }
        return st.top();
    }
};

239. 滑动窗口最大值

题目链接:https://leetcode.cn/problems/sliding-window-maximum/description/
文章讲解: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#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
视频讲解:https://www.bilibili.com/video/BV1XS4y1p7qj/?spm_id_from=pageDriver&vd_source=e70917aa6392827d1ccc8d85e19e8375
实现情况：
1、que.back()：它用于访问双端队列（std::deque）末尾的元素

class Solution {
private:
    class MyQueue {
    public:
        deque<int> que; // 定义队列
        // 入队操作 需要保持队列数值是单调从大到小
        void push(int value) {
            while (!que.empty() && value > que.back()) {
                que.pop_back();
            }
            que.push_back(value);
        }

        // 实现队列的出队函数
        void pop(int value) {
            if (!que.empty() && value == que.front()) {
                que.pop_front();
            }
        }

        // 因为队列数值是单调从大到小 ，查询当前队列里的最大值
        // 就是直接返回队列前端也就是front
        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的元素放进队列
            que.push(nums[i]);
        }
        result.push_back(que.front()); // 得到第一个最大值
        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 个高频元素

题目链接:https://leetcode.cn/problems/top-k-frequent-elements/description/
文章讲解:https://programmercarl.com/0347.%E5%89%8DK%E4%B8%AA%E9%AB%98%E9%A2%91%E5%85%83%E7%B4%A0.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
视频讲解:https://www.bilibili.com/video/BV1Xg41167Lz/?spm_id_from=pageDriver&vd_source=e70917aa6392827d1ccc8d85e19e8375
实现情况：
难点：
1、怎么统计字符法人频率
2、怎么对频率排序，
3、确定前k排名的字符

大顶堆（堆头是最大元素），小顶堆（堆头是最小元素）常用统计高频和低频的问题

直接用priority_queue（优先级队列，底层实现都是一样的，从小到大排就是小顶堆，从大到小排就是大顶堆。

class Solution {
public:

    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> map;
        for (int n : nums) { // 讲需要统计的字符存入map
            map[n]++;
        }

        // 定义一个小顶堆 大小为k
        priority_queue<pair<int, int>, vector<pair<int, int>>,
                       decltype([](const pair<int, int>& lhs,
                                   const pair<int, int>& rhs) {
                           return lhs.second > rhs.second;
                       })>
            pri_que;

        // 扫描统计各个字符出现的频率，使用小顶堆存储记录
        for (unordered_map<int, int>::iterator it = map.begin(); it !=map.end();
             it++) {
            pri_que.push(*it);
            if (pri_que.size() > k) {
                pri_que.pop();
            }
        }

        // 因为小顶堆最先弹出的是最小的元素，这样需要倒序输出数组
        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;
    }
};

#include <queue>
#include <unordered_map>
#include <utility> // for std::pair
#include <vector>

class Solution {
public:
    std::vector<int> topKFrequent(std::vector<int>& nums, int k) {
        std::unordered_map<int, int> freqMap;
        // 统计每个数字的频率
        for (int num : nums) {
            freqMap[num]++;
        }

        // 使用默认的 priority_queue（大顶堆）
        std::priority_queue<std::pair<int, int>> pri_que;
        // 注意：这里我们不直接传递 lambda，因为默认就是大顶堆

        // 填充堆，只保留频率最高的 k 个元素
        for (const auto& entry : freqMap) {
            pri_que.push(entry);
            if (pri_que.size() > k) {
                pri_que.pop();
            }
        }

        // 构建结果向量，因为是大顶堆，所以直接弹出即可（无需倒序）
        std::vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;
    }
};

总结

232.用栈实现队列
225. 用队列实现栈
-226. 有效的括号和1047. 删除字符串中的所有相邻重复项 和 逆波兰表达式求值 都是使用栈，解决方法类似
239. 滑动窗口最大值 :主要需要理解入队列操作，保持队列的数值从大到小排序
152. 347.前 K 个高频元素 了解大顶堆、小顶堆、map的使用