代码随想录算法训练营day11

1.逆波兰表达式求值

1.1 题目

. - 力扣（LeetCode）

1.2 题解

class Solution {
public:
    int evalRPN(vector<string>& tokens)
    {
        stack<int> sta;
        for (auto s : tokens)
        {
            if (s == "+" || s == "-" || s == "*" || s == "/")
            {
                int a = sta.top();
                sta.pop();
                int b = sta.top();
                sta.pop();
                if (s == "+")
                {
                    sta.push(a + b);
                }
                else if (s == "-")
                {
                    sta.push(b - a);
                }
                else if (s == "*")
                {
                    sta.push(a * b);
                }
                else
                {
                    sta.push(b / a);
                }
            }
            else
            {
                sta.push(stoi(s));
            }
        }
        return sta.top();
        
    }
};

2.滑动窗口最大值

2.1 题目

. - 力扣（LeetCode）

2.2 题解

class Solution {
public:
    
    class Mydeque
    {
    public:
        deque<int> dq;
        /// <summary>
        /// 压入元素
        /// </summary>
        /// <param name="val"></param>
        void push(int val)
        {
            while (!dq.empty() && val > dq.back())
            {
                dq.pop_back();
            }
            dq.push_back(val);
        }
        /// <summary>
        /// 弹出元素
        /// </summary>
        /// <param name="val"></param>
        void pop(int val)
        {
            if (!dq.empty() && dq.front() == val)
            {
                dq.pop_front();
            }
        }
        int GetMaxValue()
        {
            return dq.front();
        }
    };
    
    vector<int> maxSlidingWindow(vector<int>& nums, int k) 
    {
        Mydeque mydq;
        vector<int> result;
        for (int i = 0; i < k; i++)
        {
            mydq.push(nums[i]);
        }
        result.push_back(mydq.dq.front());

        //开始滑动窗口
        for (int i = k; i < nums.size(); i++)
        {
            mydq.pop(nums[i-k]);
            mydq.push(nums[i]);
            result.push_back(mydq.dq.front());
        }
        return result;
    }
    
};

自定义单调队列，队列头始终是当前的最大值，每次push一个数，都要把队列前比他小的数给卷走。

3.前K个高频元素

3.1 题目

. - 力扣（LeetCode）

3.2 题解

class Solution {
public:
    class mycompare
    {
    public:
        /// <summary>
        /// 降序排列
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        bool operator()(const pair<int, int>& a, const pair<int, int>& b)
        {
            return a.second > b.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]]++;
        }
        //定义一个大小为k的小顶堆
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycompare> pri_que;

        for (auto iter = map.begin(); iter != map.end(); iter++)
        {
            pri_que.push(*iter);
            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;
    }
};

用小顶堆来管理前k个元素