代码随想录算法训练营第十一天 | 150. 逆波兰表达式求值，239. 滑动窗口最大值，347.前 K 个高频元素，栈和队列总结

补上第十一天打卡，今天的难点主要在自定义队列和优先级队列的使用，这两个都不是很熟悉，做完一遍后印象加深，争取下次一次能做出来。

---

150.逆波兰表达式求值

题目链接

解题思路

• 使用栈，当遇到数字时入栈，遇到运算符时出栈两个数字进行计算，并将结果入栈

知识点

• string转int用stoi
• string转long long用stoll
• 时间复杂度: O(n)
• 空间复杂度: O(n)

栈的应用

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        int result;
        stack<int>st;
        for (string str : tokens) {
            if (str != "+" && str != "-" && str != "*" && str != "/") 
                st.push(stoi(str));
            else {
                int num2 = st.top(); st.pop();
                int num1 = st.top(); st.pop();
                if (str == "+") st.push(num1 + num2);
                else if (str == "-") st.push(num1 - num2);
                else if (str == "*") st.push(num1 * num2);
                else if (str == "/") st.push(num1 / num2);
            }
        }
        return st.top();
    }
};

---

239.滑动窗口最大值

题目链接

解题过程

• 暴力法能做出来，但超时，后没有思路
• 这题由于涉及到元素的头尾增删，可用deque来模拟增删的过程

知识点

• 队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。
• 设计单调队列的时候，pop，和push操作要保持如下规则：
  1. pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
  2. push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止
• 时间复杂度: O(n)
• 空间复杂度: O(k)

单调队列

class Solution {
private:
    struct myQueue {
        deque<int>deq;
        void push (int val) {
            while (!deq.empty() && val > deq.back()) deq.pop_back();
            deq.push_back(val);
        }
        void pop(int val) {
            if (!deq.empty() && val == deq.front()) deq.pop_front();
        }
        int front() {
            return deq.front();
        }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int>result;
        result.reserve(nums.size() - k + 1);
        myQueue que;
        for (int i = 0; i < k; i++) 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个高频元素

题目链接

解题过程

• 想到用优先级队列求解，但忘了怎么写了
• 要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。

知识点

• 时间复杂度: O(nlogk)
• 空间复杂度: O(n)

小顶堆

class Solution {
//小顶堆
    class myCompare {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int>umap;
        for (int n : nums) umap[n]++;
        priority_queue<pair<int, int>, vector<pair<int, int>>, myCompare> pque;
        for (auto it = umap.begin(); it != umap.end(); it++) {
            pque.push(*it);
            if (pque.size() > k) pque.pop();
        } 
        vector<int>result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pque.top().first;
            pque.pop();
        } 
        return result;
    }
};

---

栈与队列总结篇

栈与队列的理论基础

• 栈是容器适配器，底层容器使用不同的容器，导致栈内数据在内存中不一定是连续分布的。
• 缺省情况下，默认底层容器是deque，那么deque在内存中的数据分布是分段连续的。

---

栈经典题目

• 20. 有效的括号

  • 括号匹配是使用栈解决的经典问题。
  • 第一种情况，字符串里左方向的括号多余了，所以不匹配。
  • 第二种情况，括号没有多余，但是括号的类型没有匹配上。
  • 第三种情况，字符串里右方向的括号多余了，所以不匹配。

• 1047. 删除字符串中的所有相邻重复项

  • 思路就是可以把字符串顺序放到一个栈中，然后如果相同的话 栈就弹出，这样最后栈里剩下的元素都是相邻不相同的元素了。

• 150. 逆波兰表达式求值

  • 每一个子表达式要得出一个结果，然后拿这个结果再进行运算。与1047对对碰比较像。

---

队列的经典题目

• 239. 滑动窗口最大值

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

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

  • 而且不要以为实现的单调队列就是 对窗口里面的数进行排序，如果排序的话，那和优先级队列又有什么区别了呢。

  • 设计单调队列的时候，pop，和push操作要保持如下规则：

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

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

• 347.前 K 个高频元素

  • 通过求前 K 个高频元素，引出另一种队列就是优先级队列。
  • 优先级队列就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。