代码随想录训练营第十二天

第一题：

原题链接：150. 逆波兰表达式求值 - 力扣（LeetCode）

思路：

定义一个栈 stack<int> st；

当我们遇到+ - * / 的时候就需要将栈中的最后两个元素取出来，然后进行对应的操作并将结果也放入栈中，如果是数字的话将字符转换为数字放入栈中。

最后返回栈顶元素即可。

代码如下：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(int i = 0; i < tokens.size(); i++){
            if(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/"){
                int b = st.top();
                st.pop();
                int a = st.top();
                st.pop();
                if(tokens[i] == "+") st.push(a + b);
                if(tokens[i] == "-") st.push(a - b);
                if(tokens[i] == "*") st.push(a * b);
                if(tokens[i] == "/") st.push(a / b);
            }else{
                st.push(stoi(tokens[i]));
            }
        }
        int res = st.top();
        return res;
    }
};

第二题：

原题链接：239. 滑动窗口最大值 - 力扣（LeetCode）

思路：

先判断数组内容是否为0或者k是否为0，如果其中一个为0的话都返回空。

滑动窗口就是要维持一个窗口，让其中的元素保持k个。

我们定义一个双端队列deque<int> que;

然后我们定义两根指针来维持窗口的大小，j指向第一个元素的位置，i指向1-k的位置。当i大于0的时候，当在que中的第一个元素等于i指向元素的前一位时，证明该元素要弹出了，窗口移动让该元素弹出队列。当que中的元素不为空的时候，如果que的尾元素小于要新添加进来的元素时，我们将这些元素都弹出，这样能保持que的递减。然后将nums[j]添加到que的尾部。若窗口已经形成，将窗口的最大值添加到结果列表中。

deque 内 仅包含窗口内的元素 ⇒ 每轮窗口滑动移除了元素 nums[i−1] ，需将 deque内的对应元素一起删除。
deque 内的元素 非严格递减 ⇒ 每轮窗口滑动添加了元素 nums[j+1] ，需将 deque内所有 <nums[j+1]的元素删除。

代码如下：

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        if(nums.size() == 0 || k == 0) return {};
        vector<int> res;
        deque<int> dq;
        for(int j = 0, i = 1 - k; j < nums.size(); j++, i++){
            if(i > 0 && dq[0] == nums[i - 1]) dq.pop_front();
            while(!dq.empty() && dq.back() < nums[j]) dq.pop_back();
            dq.push_back(nums[j]);
            if(i >= 0) res.push_back(dq.front());
        }
        return res;
    }
};

第三题：

原题链接：347. 前 K 个高频元素 - 力扣（LeetCode）

思路：

使用小顶堆来判断前k个高频元素。

首先定义小顶堆：

struct cmp{
    bool operator()(const string& s1, const string& s2) const{
        // 和vector排序写法相反
        // a < b : [vec] 升序    [pri] 大顶堆
        return (s1.size() < s2.size()) || (s1.size() == s2.size() && s1 > s2);
    }
};

首先看看如何定义：

根据上面的代码我们知道如果要定义小顶堆的话return是a > b；

我们的定义如下：

class mycomparsion{
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs){
            return lhs.second > rhs.second;
        }
    };

有了这个就很好操作了，先定义一个unorderd_map用来存放每个元素出现的个数。然后遍历map存放到小顶堆中，其中只需要维持小顶堆的个数为k个就行，多的话就从堆顶pop掉。

最后反向将小顶堆中的元素放入结果数组中，返回即可。

代码如下：

class Solution {
public:
    class mycomparsion{
    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;
        for(int i = 0; i < nums.size(); i++){
            map[nums[i]]++;
        }
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparsion> 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;
    }
};