代码随想录算法训练营Day.11 栈与队列 part02 | 逆波兰表达式求值 滑动窗口最大值 前 K 个高频元素

150.逆波兰表达式求值

其实就是运算的模拟，相比于正常的计算表达式，逆波兰表达式的表达还更为简单，遇到数字入栈，遇到计算符出栈两数，计算结果入栈，如此反复。

    class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        std::stack<int> sNum;
        for(std::string str : tokens)
        {
            char c = str[0];
            if((c == '+' || c == '-' 
            || c == '*' || c == '/') && str.size() == 1)
            {
                int B = sNum.top();
                sNum.pop();
                int A = sNum.top();
                sNum.pop();
                int res{0};
                if(c == '+')
                {
                    res = A + B;
                }
                else if(c == '-')
                {
                    res = A - B;
                }
                else if(c == '/')
                {
                    res = A / B;
                }
                else if(c == '*')
                {
                    res = A * B;
                }
                sNum.push(res);
            }
            else
            {
                int num = std::stoi(str);
                sNum.push(num);
            }
        }
        return sNum.top();
    }
};
// (9+3)*(-11)
// 

239.滑动窗口最大值

单调队列的维护，主要解决的问题就是如何在窗口内最大值出窗口后，如何保证能找到下一个值，其实就是在入窗口时持续维护一个单调队列。如代码所示，qMax数组维护为单调队列，入窗口值大于等于qBack尾部值时qBack值出队列，直到从尾部插入该值能保证队列单调为止。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> res{};
        vector<int> qMax(nums.size(),0);
        int qFront{0};
        int qBack{0};
        int pop{0};
        // init, 单调队列
        qMax[qBack] = nums[0]; 
        for(int i = 1; i <= k - 1; i ++)
        {
            if(qMax[qBack] <= nums[i])
            {
                while(qBack >= qFront 
                && qMax[qBack] < nums[i])
                {
                    qBack --;
                }
                
            }
            qMax[++qBack] = nums[i];
        }
        res.push_back(qMax[qFront]);
        for(int i = k; i < nums.size(); i ++)
        {
            if(nums[pop++] == qMax[qFront])
            {
                qFront ++;
            }
            if(qMax[qBack] <= nums[i])
            {
                while(qBack >= qFront
                && qMax[qBack] < nums[i])
                {
                    qBack --;
                }
            }
            qMax[++qBack] = nums[i];
            res.push_back(qMax[qFront]);
        }
        if(res.size() == 0) res.push_back(qMax.front());
        return res;
    }
};

347.前 K 个高频元素 （待复习）

维护一个小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素，这里直接贴随想录代码：

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;

    }
};