打卡第十一天：逆波兰表达式求值、滑动窗口最大值、前K个高频元素

1、逆波兰表达式求值

题目

文章

视频

逆波兰表达式：是一种后缀表达式，所谓后缀就是指运算符写在后面。

平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。

该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

• 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。

• 适合用栈操作运算：遇到数字则入栈；遇到运算符则取出栈顶两个数字进行计算，并将结果压入栈中。

思路：逆波兰表达式是用后序遍历的方式把二叉树序列化。

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st; //需要用long long
        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]));// 如果当前标记是数字，将其转换为 long long 类型并压入栈中
            }
        }
        int result = st.top();// 获取栈顶元素，即最终计算结果
        st.pop(); 
        return result;
    }
};

2、滑动窗口最大值

题目

文章

视频

暴力法是O(n×k)的算法。此时我们需要一个队列，这个队列呢，放进去窗口里的元素，然后随着窗口的移动，队列也一进一出，每次移动之后，队列告诉我们里面的最大值是什么。

每次窗口移动的时候，调用que.pop(滑动窗口中移除元素的数值)，que.push(滑动窗口添加元素的数值)，然后que.front()就返回我们要的最大值。

其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。

那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。C++中没有直接支持单调队列，需要我们自己来实现一个单调队列

1. pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
2. push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止

保持如上规则，每次窗口移动的时候，只要问que.front()就可以返回当前窗口的最大值。数据结构deque最合适。

class Solution {
private:
    // 定义一个内部类 MyQueue 表示单调队列（从大到小）
    class MyQueue { // 单调队列（从大到小）
    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) {
        MyQueue que; // 创建一个单调队列实例
        vector<int> result; // 用于存储每个滑动窗口的最大值

        // 先将前 k 个元素加入队列
        for (int i = 0; i < k; i++) {
            que.push(nums[i]);
        }

        // 记录前 k 个元素中的最大值
        result.push_back(que.front());

        // 遍历数字数组，从 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; // 返回结果数组
    }
};

3、前K个高频元素

题目

文章

视频

这道题目主要涉及到如下三块内容：

1. 要统计元素出现频率
2. 对频率排序
3. 找出前K个高频元素

首先统计元素出现的频率，这一类的问题可以使用map来进行统计。

然后是对频率进行排序，这里我们可以使用一种 容器适配器就是优先级队列。就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。而且优先级队列内部元素是自动依照元素的权值排列。那么它是如何有序排列的呢？

缺省情况下priority_queue利用max-heap（大顶堆）完成对元素的排序，这个大顶堆是以vector为表现形式的complete binary tree（完全二叉树）。

堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。

为什么不用快排呢， 使用快排要将map转换为vector的结构，然后对整个数组进行排序， 而这种场景下，我们其实只需要维护k个有序的序列就可以了，所以使用优先级队列是最优的。

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

class Solution {
public:
    // 定义一个小顶堆的比较器类
    class mycomparison {
    public:
        // 重载操作符，用于比较两个pair，根据第二个值（频率）进行比较
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second; // 当lhs的频率大于rhs的频率时返回true，这样可以构造一个小顶堆
        }
    };

    vector<int> topKFrequent(vector<int>& nums, int k) {
        // 创建一个unordered_map来统计每个元素出现的频率
        unordered_map<int, int> map; // map<nums[i],对应出现的次数>
        for (int i = 0; i < nums.size(); i++) {
            map[nums[i]]++; // 如果元素nums[i]存在于map中，则增加其出现的次数；如果不存在，则初始化为1
        }

        // 定义一个小顶堆，这里使用定义好的比较器类mycomparison
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;

        // 遍历map中的所有频率数值，并维护一个大小为k的小顶堆
        for (auto it = map.begin(); it != map.end(); it++) {
            pri_que.push(*it); // 将元素和值的pair加入小顶堆
            if (pri_que.size() > k) { // 如果堆的大小超过k，则弹出堆顶元素（频率最小的元素），保持堆的大小为k
                pri_que.pop();
            }
        }

        // 找出前K个高频元素，因为小顶堆先弹出的是频率最小的，所以倒序输出
        vector<int> result(k); // 定义结果数组，大小为k
        for (int i = k - 1; i >= 0; i--) { // 从后往前填充结果数组
            result[i] = pri_que.top().first; // 取出堆顶元素的值（key）
            pri_que.pop(); // 弹出堆顶元素
        }
        
        return result; // 返回结果数组
    }
};