代码随想录算法训练营第十一天| 150. 逆波兰表达式求值、239. 滑动窗口最大值、347.前 K 个高频元素

150. 逆波兰表达式求值

150. 逆波兰表达式求值

栈与递归之间在某种程度上是可以转换的。其实逆波兰表达式相当于是二叉树中的后序遍历。后缀表达式对计算机来说是非常友好的。

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(auto c:tokens){
            if(c=="+"||c=="-"||c=="*"||c=="/"){
                int nums1=st.top();
                st.pop();
                int nums2=st.top();
                st.pop();
                if(c=="+") st.push(nums1+nums2);
                if(c=="-") st.push(nums2-nums1);
                if(c=="*") st.push(nums1*nums2);
                if(c=="/") st.push(nums2/nums1);
            }else{
                st.push(stoi(c));
            }
        }
        int result=st.top();
        st.pop();
        return result;
    }
};

stoll 是 C++ 标准库中的一个函数，用于将字符串转换为 long long 类型的整数。

stoi 是 C++ 标准库中的一个函数，用于将字符串转换为 int 类型的整数。

239. 滑动窗口最大值

239. 滑动窗口最大值

用deque实现了一个单调队列，很有难度

class Solution {
private:
    class MyQueue { //单调队列（从大到小）
    public:
        deque<int> que; // 使用deque来实现单调队列
        // 每次弹出的时候，比较当前要弹出的数值是否等于队列出口元素的数值，如果相等则弹出。
        // 同时pop之前判断队列当前是否为空。
        void pop(int value) {
            if (!que.empty() && value == que.front()) {
                que.pop_front();
            }
        }
        // 如果push的数值大于入口元素的数值，那么就将队列后端的数值弹出，直到push的数值小于等于队列入口元素的数值为止。
        // 这样就保持了队列里的数值是单调从大到小的了。
        void push(int value) {
            while (!que.empty() && value > que.back()) {
                que.pop_back();
            }
            que.push_back(value);

        }
        // 查询当前队列里的最大值 直接返回队列前端也就是front就可以了。
        int front() {
            return que.front();
        }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQueue que;
        vector<int> result;
        for (int i = 0; i < k; i++) { // 先将前k的元素放进队列
            que.push(nums[i]);
        }
        result.push_back(que.front()); // result 记录前k的元素的最大值
        for (int i = k; i < nums.size(); i++) {
            que.pop(nums[i - k]); // 滑动窗口移除最前面元素
            que.push(nums[i]); // 滑动窗口前加入最后面的元素
            result.push_back(que.front()); // 记录对应的最大值
        }
        return result;
    }
};

class类中不要忘记public: 

题解中单调队列里的pop和push接口，仅适用于本题哈。单调队列不是一成不变的，而是不同场景不同写法，总之要保证队列里单调递减或递增的原则，所以叫做单调队列。

C++中deque是stack和queue默认的底层实现容器，deque是可以两边扩展的，而且deque里元素并不是严格的连续分布的。

deque容器支持在两端都进行插入和删除操作

que.front   que.back   que.push_back   que.push_front   que.pop_back   que.pop_front

操作之前检查que.empty()

347.前 K 个高频元素

347. 前 K 个高频元素

优先级队列就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。

缺省情况下priority_queue利用max-heap（大顶堆）完成对元素的排序，这个大顶堆是以vector为表现形式的complete binary tree（完全二叉树）。

• push(value)：将元素value插入优先队列中，并维持堆的性质。
• pop()：移除堆顶元素，即优先级最高的元素。
• top()：返回堆顶元素的值，但不移除它。

这些操作使priority_queue特别适合用于实现基于优先级的任务调度、处理应急任务等场景。

要用小顶堆，因为要统计最大前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> map; // map<nums[i],对应出现的次数>
        for (int i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }

        // 对频率排序
        // 定义一个小顶堆，大小为k
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;

        // 用固定大小为k的小顶堆，扫面所有频率的数值
        for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
            pri_que.push(*it);
            if (pri_que.size() > k) { // 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                pri_que.pop();
            }
        }

        // 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;

    }
};

大顶堆：priority_queue<int>或使用默认的priority_queue。

小顶堆：priority_queue<int, vector<int>, greater<int>>或通过自定义比较器来实现。

greater<T> 是 <functional> 头文件中的一个模板类，用于比较两个值的大小，默认实现为“>`”。

MyComparison：定义了一个比较器类，其中的operator()函数定义了比较规则。具体来说，当lhs > rhs时，返回true，这意味着在堆的结构中，lhs将排在rhs之后。由于我们希望建立一个小顶堆，这个比较器实现了这样的需求。

• operator()：这是一个重载的比较操作符，用来定义两个元素之间的比较规则。
• pair<int, int>：堆中的元素类型是pair<int, int>，其中第一个int是数组中的元素值，第二个int是该元素的频率。
• lhs.second > rhs.second：这里定义的比较规则是，如果lhs（左边的元素）的频率大于rhs（右边的元素）的频率，则返回true。这意味着频率较小的元素将优先排在堆顶。

priority_queue是一个模板类，它的定义需要三个模板参数：

1. 数据类型 (T)：即优先队列中保存的元素类型。
2. 容器类型 (Container)：存储元素的底层容器类型，通常是一个序列容器。默认情况下，priority_queue使用std::vector作为底层容器。
3. 比较器类型 (Compare)：用于决定优先队列中的元素顺序的比较器。默认情况下，priority_queue是大顶堆，即最大元素在堆顶。如果要定义小顶堆或自定义顺序，需要提供一个自定义的比较器。