代码随想录打卡第十二天

代码随想录–栈与队列部分

day12 栈与队列第二天

---

---

一、力扣150–逆波兰表达式求值

代码随想录题目链接：代码随想录

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。
请你计算该表达式。返回一个表示表达式值的整数。

逆波兰表示法的百度链接：逆波兰表示法

知道什么是逆波兰表示法后，这个题也就没什么难度了

遇到数字就入栈，遇到运算符就出栈两个数字，运算的结果再入栈即可

代码如下：

class Solution {
public:
    bool isChar(string & input)
    {
        return (input == "+" || input == "/" || input == "*" || input == "-");
    }

    int evalRPN(vector<string>& tokens) {
        stack<int> result;
        for(auto element : tokens)
        {
            if(!isChar(element)) result.push(stoll(element));
            else
            {
                int backward = result.top();
                result.pop();
                int forward = result.top();
                result.pop();
                if(element == "+") result.push(forward + backward);
                if(element == "-") result.push(forward - backward);
                if(element == "/") result.push(forward / backward);
                if(element == "*") result.push(forward * backward);
            }
        }
        return result.top();
    }
};

注意，将string转为int需要用stol、stoi、stoll等函数

二、力扣239–滑动窗口最大值

代码随想录题目链接：代码随想录

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回 滑动窗口中的最大值 。

刷到的第一个困难题，最普通的做法就是用队列实现滑动窗口，然后在队列里面找最大值输出

这样做的问题是k大的时候，最大值找起来非常慢，时间复杂度高达$O(n\times k)$

引入单调队列来解决该问题，即维护一个单调递增或递减的队列

设计这样的一个队列，当接收到push时，看一下这个数字和队尾谁大，如果它大，就把队尾扔了，把它加进来

一直到它遇到比它大的队尾，就不再往前，比如下面的例子，4大于1但是不大于5，停在了第二位

而5大于2和3，就在第一位，这样做的好处是间接地将滑动窗口内的数字进行了排序，由大到小

而当pop时，就要担心会不会该pop的元素不是这个队列的队首元素

所以pop时加个判断，如果一样，就pop掉队首，如果不一样，说明这个元素早就不在了，那就不做任何处理

这样就能保证队首始终是滑动窗口内的最大值，并且时间复杂度为$O(n)$

代码如下：因为要从队伍pop出来元素，所以要用双头队列，也就是deque来构建这个单调队列

class Solution {
private:
    class Myqueue
    {
    public:        
        void pop(int input)
        {
            if(!myqueue.empty() && input == myqueue.front()) myqueue.pop_front();
        }

        void push(int input)
        {
            while(!myqueue.empty() && input > myqueue.back())myqueue.pop_back();
            myqueue.push_back(input);
        }

        int front()
        {
            return myqueue.front();
        }

    private:
        deque<int> myqueue;
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        Myqueue que;
        vector<int> result;
        for(int i = 0; i < k; i++) que.push(nums[i]);
        result.push_back(que.front());
        for(int i = 0; i < nums.size() - k ; i++)
        {
            que.pop(nums[i]);
            que.push(nums[i+k]);
            result.push_back(que.front());
        }
        return result;
    }
};

主要是思路清晰不清晰，如果能够想到构建单调队列这一结构，就好写多了

三、力扣347–前k个高频元素

代码随想录题目链接：代码随想录

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

粗暴点做就是遍历数组，用哈希表存下来每个数字和他们出现的次数，再根据次数从大到小排序，输出前k个数字

随想录的做法就是在排序这里用了堆来加速

代码如下：

class Solution {
public:
    class mycomparison {
    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> hash;
        for(int ele : nums) hash[ele]++;

        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;
        for (unordered_map<int, int>::iterator it = hash.begin(); it != hash.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;
    }
};

其实偷懒的话，用C++的sort函数也能直接做

class Solution {
public:
    bool compare(const std::pair<int, int>& a, const std::pair<int, int>& b) {
        return a.second > b.second; 
    }
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> hash;
        for(int ele : nums) hash[ele]++;
        
        std::vector<std::pair<int, int>> sorted_vector(hash.begin(), hash.end());
        
        std::sort(sorted_vector.begin(), sorted_vector.end(),
              [](const std::pair<int, int>& a, const std::pair<int, int>& b) {
                  return a.second > b.second; 
              });
        vector<int> result(k);
        for (int i = k - 1, j = 0; i >= 0; i--, j++) 
        {
            result[i] = sorted_vector[j].first;
        }
        return result;
    }
};