第五章 栈与队列part02

150. 逆波兰表达式求值

stoll(tokens[i])
atoi：将字符串转换为整型（int 类型）。
strtol

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        // 力扣修改了后台测试数据，需要用longlong
        stack<long long> st; 
        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]));
            }
        }

        int result = st.top();
        st.pop(); // 把栈里最后一个元素弹出（其实不弹出也没事）
        return result;
    }
};

239. 滑动窗口最大值

#include <deque>
#include <vector>
using namespace std;
// @lc code=start
class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        if (nums.size() == 0)
            return {};
        MonoQue MonoQue;
        vector<int> ans;
        for(int i = 0;i < k;i++ )
        {
            MonoQue.push(nums[i]);
        }
        ans.push_back(MonoQue.front());
        for (int i = k; i < nums.size(); i++)
        {
            MonoQue.push(nums[i]);
            MonoQue.pop(nums[i-k]);
            ans.push_back(MonoQue.front());
        }
        return ans;    
    }
private:
class MonoQue
{
public:
    deque<int> que;
    void pop(int value)
    {
        if(!que.empty()&&que.front() == value)
        {
            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();
    }
};
};

347.前 K 个高频元素

优先级队列（大顶堆）
仿函数重载中
// 小顶堆
class mycomparison {
public:
bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
return lhs.second > rhs.second;
}
};
>号代表小顶堆可以理解为false时才调整，当大于时不调整说明是小顶堆

#include<unordered_map>
#include<vector>
#include <queue>
using namespace std;

class Solution {
public:
    class pair_comparison
    {
    public:
        bool operator()(pair<int,int>&x1,pair<int,int>&x2)
        {
            return x1.second > x2.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>>,pair_comparison> MinHeap;
        for (unordered_map<int,int>::iterator it = map.begin(); it != map.end(); it++)
        {
            MinHeap.push(*it);
            if (MinHeap.size()>k)
            {
                MinHeap.pop();
            }
        }
        vector<int> ans(k);
        for (int i = k-1; i >= 0; i--)
        {
            ans[i] = MinHeap.top().first;
            MinHeap.pop();
        }
        return ans;      
    }
};