代码随想录day11|150.逆波兰表达式求值、239.滑动窗口最大值、347.前K个高频元素

提示：DDU，供自己复习使用。欢迎大家前来讨论~

---

栈与队列Part02以及总结

了解栈与队列的内部实现机制

一、基础知识点

查缺补漏：

在C++中，vector<string>& tokens 和 vector<string> tokens 表示的含义是不同的：

1. 引用类型：vector<string>& tokens 是一个引用，指向一个 vector<string> 类型的容器。这意味着它并不实际持有数据，而是引用（或者说是别名）另一个已经存在的 vector<string>。当你通过这个引用修改数据时，实际上是在修改它所引用的那个 vector<string> 的内容。
2. 值类型：vector<string> tokens 是一个值类型，表示一个实际的 vector<string> 容器实例。它拥有自己的内存空间和数据副本。当你对它进行修改时，不会影响到其他同名的 vector<string> 容器，除非它们之间有明确的引用关系。

引用类型（vector<string>& tokens）是指向另一个容器的引用，而值类型（vector<string> tokens）则是容器本身的一个独立实例。使用引用可以节省内存，因为不需要复制整个容器的数据，但同时也需要注意引用所指向的原始容器的生命周期，以避免悬垂引用（dangling reference）的问题。而值类型则更加安全，因为它拥有自己的数据副本，但可能会因为复制操作而消耗更多的内存和时间。

二、题目

题目一：150. 逆波兰表达式求值

leetcode题目链接

**逆波兰表达式：**是一种后缀表达式，所谓后缀就是指运算符写在后面。

平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。

该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

• 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
• 适合用栈操作运算：遇到数字则入栈；遇到运算符则取出栈顶两个数字进行计算，并将结果压入栈中。

解题思路：

1. 初始化栈：创建一个栈来存储操作数。
2. 遍历表达式：从左到右遍历逆波兰表达式中的每个元素。
3. 处理元素：
   • 如果元素是数字，将其压入栈中。
   • 如果元素是操作符（如+ - * /）：
     • 从栈中弹出所需数量的操作数（对于二元操作符，需要两个）。
     • 执行相应的运算。
     • 将运算结果压回栈中。
4. 最终结果：遍历完成后，栈顶元素即为表达式的计算结果。

细节：

int 通常是32位的，而 long long 是64位的

stoll 是 <sstream> 头文件中定义的一个函数，用于将字符串转换为 long long 类型的数值。

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        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;
    }
};

• 时间复杂度: O(n)
• 空间复杂度: O(k)

题目二： 239. 滑动窗口最大值

leetcode题目链接

解题思路：

1.弹出当前小于当前遍历值的所有队尾元素

2.超出窗口长度时弹出队首元素

3.判断是否达到窗口长度，达到了就开始记录答案

总结一下就是即使去掉无用的数据,保证双端队列有序。（当前数字大于等于队尾，弹出队尾；弹出队首不在窗口内的元素。）

需要一个什么样的数据结构？维护一个单调队列来实现。

单调队列

• 移除最左边的元素，移除最右边的元素，在最右边插入元素 -》双端队列

• 在对手和对位单挑递减 -》单调性

细节：

1. 正确弹出元素：在窗口滑动时，使用 que.pop(nums[i - k]) 弹出窗口最前面的元素。这里需要确保弹出的元素是窗口中正确的最大值，因此需要检查它是否等于队列的前端元素。
2. 维护单调性：MyQueue 的 push 方法确保队列保持单调递减的特性。如果新加入的元素 nums[i] 大于队列的后端元素，它会一直弹出队列后端的元素，直到 nums[i] 小于或等于队列的后端元素，然后将 nums[i] 压入队列。
3. 避免重复元素：MyQueue 的 pop 方法确保队列中的元素是唯一的，防止同一个元素在窗口内被多次计算。
4. 边界条件处理：在 push 和 pop 方法中，需要检查队列是否为空，以避免在空队列上执行操作。
5. 结果数组的更新：每次窗口滑动后，将队列前端的元素添加到结果数组 result，这代表了当前窗口的最大值。

代码如下：

class Solution {
private:
    class MyQueue { //单调队列（从大到小）
    public:
        deque<int> que; // 使用deque来实现单调队列
        //如果传入的 value 值等于队列头部的元素值，pop 函数将执行 que.pop_front() 操作，从队列头部移除该元素。
        // 这样做是为了确保队列中的元素是唯一的，并且保持队列的单调递减特性。
        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++) {
            
            // 如果 nums[i - k] 不等于队列前端的元素，它可能不是队列中的第一个元素，或者已经被之前的操作从队列中移除。
            // 在这种情况下，直接移除可能会导致队列状态错误，因为队列中可能存在比 nums[i - k] 更大的元素，
			// 检查 nums[i - k] 是否等于队列前端元素是为了在窗口滑动时正确维护单调队列的状态，
            // 确保队列正确地反映当前窗口的最大值，避免因错误弹出而导致队列状态不正确。
            que.pop(nums[i - k]); 
            que.push(nums[i]); // 滑动窗口前加入最后面的元素
            result.push_back(que.front()); // 记录对应的最大值
        }
        return result;
    }
};    

• 时间复杂度: O(n)

• 空间复杂度: O(k)

另一个直接的思路，代码如下：

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

            if (i >= k - 1)
                result.push_back(q.front());
        }
        return result;
    }
};

题目三： 347.前 K 个高频元素

leetcode题目链接

大/小顶堆的应用， 在C++中就是优先级队列。

首先统计元素出现的频率，这一类的问题可以使用map来进行统计。

然后是对频率进行排序，这里我们可以使用一种 容器适配器就是优先级队列。

解题思路：

1. 要统计元素出现频率

2. 对频率排序

3. 找出前K个高频元素

什么是优先级队列呢？

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

而且优先级队列内部元素是自动依照元素的权值排列。那么它是如何有序排列的呢？

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

什么是堆呢？

堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。

所以大家经常说的大顶堆（堆头是最大元素），小顶堆（堆头是最小元素），如果懒得自己实现的话，就直接用**priority_queue（优先级队列）**就可以了，底层实现都是一样的，从小到大排就是小顶堆，从大到小排就是大顶堆。

因为最后要留下来的是前k个最大值，所以是选择小顶堆，将小的元素弹出去。

细节：

在堆排序和优先级队列中，比较操作的应用方式决定了堆的类型：小顶堆通过比较确保父节点的值大于子节点（left > right），从而实现从小到大排序；而大顶堆则通过相反的比较（right > left），确保父节点的值小于子节点，实现从大到小排序。

这种差异反映了不同数据结构设计中对元素顺序的不同需求。

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;

    }
};

• 时间复杂度: O(nlogk)
• 空间复杂度: O(n)

三、栈与队列总结篇

3.1栈与队列的理论基础

1.灵魂四问：

1. C++中stack，queue 是容器么？
2. 我们使用的stack，queue是属于那个版本的STL？
3. 我们使用的STL中stack，queue是如何实现的？
4. stack，queue 提供迭代器来遍历空间么？

2.可以出一道面试题：栈里面的元素在内存中是连续分布的么？

这个问题有两个陷阱：

• 陷阱1：栈（std::stack）是一个容器适配器，它提供了后进先出（LIFO）的数据结构接口。栈本身并不存储元素，而是使用一个底层容器来存储元素。这个底层容器可以是任何序列容器，比如 std::vector、std::deque 或 std::list。由于不同的容器在内存中存储数据的方式不同，所以不能一概而论地说栈中的元素在内存中是连续分布的。

• 陷阱2：当使用 std::stack 而没有指定底层容器类型时，默认情况下使用的是 std::deque（双端队列）。std::deque 是为了提供快速的随机访问和两端的快速插入删除操作而设计的。它在内存中的数据分布通常是不连续的，因为它可能会使用多个固定大小的内存块来存储元素，这些块之间不一定连续。

这个问题的意思是，如果面试者没有深入理解 std::stack 的底层实现细节，可能会错误地认为栈中的元素总是在内存中连续分布的。实际上，这取决于栈所使用的具体底层容器。如果使用的是 std::vector，那么元素在内存中是连续的；如果使用的是 std::deque 或 std::list，则元素在内存中是不连续的。

3. 值得一提的是，用用队列实现栈中，其实只用一个队列就够了。

一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部，此时在去弹出元素就是栈的顺序了。

描述的是如何使用队列来模拟栈的弹出（pop）操作。在标准的队列操作中，元素是从队列的尾部添加，从队列的头部移除，这遵循先进先出（FIFO）的原则。然而，栈的操作是后进先出（LIFO），即最后添加的元素是最先被移除的。

这种方法虽然可以模拟栈的行为，但效率不高，因为每次弹出操作都需要将队列中的所有元素重新排队，这将消耗额外的时间。然而，这种方法在某些特定情况下，当队列的其他操作比栈的操作更频繁时，可以作为一种简便的模拟手段。

3.2栈经典题目

括号匹配问题

括号匹配是使用栈解决的经典问题。

在写代码之前要分析好有哪几种不匹配的情况，如果不动手之前分析好，写出的代码也会有很多问题。

先来分析一下 这里有三种不匹配的情况，

1. 第一种情况，字符串里左方向的括号多余了，所以不匹配。
2. 第二种情况，括号没有多余，但是括号的类型没有匹配上。
3. 第三种情况，字符串里右方向的括号多余了，所以不匹配。

这里还有一些技巧，在匹配左括号的时候，右括号先入栈，就只需要比较当前元素和栈顶相不相等就可以了，比左括号先入栈代码实现要简单的多了！

字符串去重问题

1047. 删除字符串中的所有相邻重复项

思路就是可以把字符串顺序放到一个栈中，然后如果相同的话 栈就弹出，这样最后栈里剩下的元素都是相邻不相同的元素了。

逆波兰表达式问题

3.3队列的经典题目

滑动窗口最大值问题

讲解了一种数据结构：单调队列。

主要思想是队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。

那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。C++中没有直接支持单调队列，需要我们自己来一个单调队列

而且不要以为实现的单调队列就是 对窗口里面的数进行排序，如果排序的话，那和优先级队列又有什么区别了呢。

设计单调队列的时候**，pop，和push**操作要保持如下规则：

1. pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作。（避免错误操作）
2. push(value)：如果push的元素value大于入口元素的数值，那么就将队列出口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止（保证单调性）

保持如上规则，每次窗口移动的时候，只要问que.front()就可以返回当前窗口的最大值。

会对单调队列都有一些困惑，首先要明确的是，题解中单调队列里的pop和push接口，仅适用于本题。

单调队列不是一成不变的，而是不同场景不同写法，总之要保证队列里单调递减或递增的原则，所以叫做单调队列。

不要以为本题中的单调队列实现就是固定的写法。

使用deque作为单调队列的底层数据结构，C++中deque是stack和queue默认的底层实现容器，deque是可以两边扩展的，而且deque里元素并不是严格的连续分布的

求前 K 个高频元素

通过求前 K 个高频元素，引出另一种队列就是优先级队列。

优先级队列就像是个特殊的队列，它里面的元素会根据一定的优先级（通常是元素的值）自动排序。虽然看起来像普通的队列，只能从队头取出元素，从队尾加入元素，但它的内部其实是个堆，能够保证取出的总是当前最重要的元素。

堆是一种特殊的树，每个节点的值要么比它的子节点都大（大顶堆），要么都小（小顶堆）。C++中的 priority_queue 默认情况下是大顶堆，意味着队头总是最大的元素。**如果你用 priority_queue，就不用自己费劲去实现堆了，**直接用，它会自动帮你管理元素的排序。想要最小的元素在队头，就改用小顶堆。

本题就要使用优先级队列来对部分频率进行排序。 注意这里是对部分数据进行排序而不需要对所有数据排序！

---

总结

1. 栈的模拟：通过实现队列的功能来加深对栈操作的理解。
2. 队列的模拟：反之，用队列实现栈的功能，以掌握队列的基本原理。
3. 栈的应用：通过括号匹配、字符串去重、逆波兰表达式等实际问题，展示了栈的实用技巧。
4. 队列的应用：介绍了单调队列和优先级队列，这两种队列在特定问题中非常有效，是解决问题的关键工具。

加油，坚持住，冲一波，争取理解思路就好了。