随想录一刷Day13——栈与队列

Day13_栈与队列

6. 逆波兰表达式求值

150. 逆波兰表达式求值
思路

用栈模拟，注意运算顺序和溢出情况即可

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        long tokens_size = tokens.size();
        stack<long> stk; // 数据类型定义成 long，否则会产生乘法溢出
        long nums1, nums2;
        for (int i = 0; i < tokens_size; ++i) {
            if (tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/") {
                nums2 = stk.top(); stk.pop();
                nums1 = stk.top(); stk.pop();
                if (tokens[i] == "+") stk.push(nums1 + nums2); // 注意运算顺序，先出栈的放在第二个运算位置
                else if (tokens[i] == "-") stk.push(nums1 - nums2);
                else if (tokens[i] == "*") stk.push(nums1 * nums2);
                else if (tokens[i] == "/") stk.push(nums1 / nums2);
            } else {
                stk.push(stoi(tokens[i]));
            }
        }
        return stk.top();
    }
};

7. 滑动窗口最大值

239. 滑动窗口最大值
思路

单调队列的思想，就是在队列头部维护滑动窗口内的最大或最小值
偷卡哥动图一张

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int nums_size = nums.size();
        vector<int> ans;
        deque<int> que;
        for (int i = 0; i < nums_size; ++i) {
            while (!que.empty() && que.back() < nums[i]) que.pop_back(); // 维护队列是单调不增的的，保证队首最大
            que.push_back(nums[i]);
            if (i >= k - 1) { // 从填满第一个窗口的之后开始获取答案
                ans.push_back(que.front());
                if (nums[i - k + 1] == que.front()) que.pop_front(); // 队首作为滑动窗口最左侧的元素处理之后，移除窗口（单调队列）
            }
        }
        return ans;
    }
};

8. 前 K 个高频元素

347. 前 K 个高频元素
思路

1. 统计每个数字出现的频次
2. 对频次排序（使用堆来实现）
3. 输出前k大频次对应的数字

抄了一手优先队列自定义排序方法，熟悉一下vector初始化，priority_queue的定义，迭代器的使用

class Solution {
    // 小顶堆
    class mycmp {
        public:
            bool operator()(const pair<int, int>&l_unit, const pair<int, int>&r_unit) {
                return l_unit.second > r_unit.second;
            }
    };
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        vector<int> ans(k);
        unordered_map<int, int> map;
        int nums_size = nums.size();
        for (int i = 0; i < nums_size; ++i) { // 统计每个数字出现的频次
            map[nums[i]]++;
        }

        // 建立小顶堆
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycmp> pri_que;

        // 将频次放入小顶堆
        for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
            pri_que.push(*it);
            if (pri_que.size() > k) { // 维护堆中只有最大k个频次
                pri_que.pop();
            }
        }

        // 从堆中取出答案,先取出的是最小的，应该放在答案的最后一个
        for (int i = k - 1; i >= 0; --i) {
            ans[i] = pri_que.top().first;
            pri_que.pop();
        }
        return ans;
    }
};