代码随想录算法训练营第十一天|Leetcode20 有效的括号 、Leetcode1047 删除字符串中的所有相邻重复项、Leetcode150 逆波兰表达式求值

● Leetcode20 有效的括号

题目链接：Leetcode20 有效的括号
视频讲解：代码随想录|有效的括号
题目描述：给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

示例 1：
输入：s = “()”
输出：true
示例 2：
输入：s = “()[]{}”
输出：true
示例 3：
输入：s = “(]”
输出：false

● 解题思路

有效的括号是典型的用栈完成的题目
对于本题的合法括号不仅对于规定(), [], {}，同时对于其匹配的顺序也有要求。接下来我们需要考虑哪些情况是不合法的括号：
（1）当左括号多余时；

假设存在字符串({[]}()，我们可以判断对于此字符串多出一个(，因此必定有字符无法匹配合法括号，返回false；

（2）当左括号和右括号不匹配时；

假设存在字符串{[(]]}，我们可以判断每一个左括号都有一个右括号与之配对，但与（匹配的不是)而是]，因此无法匹配合法括号，返回false；

（3）当右括号多余时；

假设字符串{[()]}))，显然有多余的)无法配对成合法括号，返回false；

当我们知道了在哪些情况下括号无法匹配合法时，我们应该对其怎么操作呢？
我们首先可以遍历字符串s，然后对之后是否存在合法括号与之匹配合法，但这种做法无疑使得我们的判断条件变得特别复杂，因此我们需要寻找一个简便易懂的方法帮助我们判断有效的括号。

这里我们需要用到stack，对于字符的具体操作思想：当我们遇到左括号时，我们在栈中压入其合法右括号，因此题目对于字符匹配需要合法之外，在顺序上也有要求，当我们遍历到右括号时，判断栈顶元素是否与其相等即可，以上便是我们本题的整体思想。
（1）对于情况一： 当我们遍历结束所有字符时，因为有多余的左括号，所以在栈中仍存在无法匹配的右括号，栈不为空；
（2）对于情况二： 栈顶元素无法与遍历元素判断相等，因此无法返回true；
（3）对于情况三： 当我们遍历到多余的右括号时，栈为空，没有合法左括号匹配；

时间复杂度：O(n) 空间复杂度：O(n)

● 代码实现

class Solution {
public:
    bool isValid(string s) {
        //当s长度为奇数，必定有元素无法构成合法括号
        if(s.size() % 2 != 0) return false;

        stack<int> st;
        //处理三种情况
        for(int i = 0; i < s.size(); i++)
        {
            if(s[i] == '(') st.push(')');
            else if(s[i] == '[') st.push(']');
            else if(s[i] == '{') st.push('}');

            //对第二种和第三种情况处理
            else if(st.empty() || st.top() != s[i]) return false;

            //满足合法括号，弹出栈顶元素
            else st.pop();
        }

        //对第一种情况处理
        return st.empty();
    }
};

● Leetcode1047 删除字符串中的所有相邻重复项

题目链接：Leetcode1047 删除字符串中的所有相邻重复项
视频讲解：代码随想录|删除字符串中的所有相邻重复项
题目描述：给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
在 S 上反复执行重复项删除操作，直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：
输入：“abbaca”
输出：“ca”
解释：
例如，在 “abbaca” 中，我们可以删除 “bb” 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 “aaca”，其中又只有 “aa” 可以执行重复项删除操作，所以最后的字符串为 “ca”。

● 解题思路

使用栈完成本题，当栈为空或者栈顶元素与遍历元素不想同时，即相邻元素不相等，我们将其压入栈中，否则就是相邻元素相等，需要将栈顶元素弹出。
因为我们使用栈完成本题栈内最后剩余元素弹出是逆序，我们需要将其转换为字符串并逆序才能输出正确答案，因此可以使用相同思路，但使用字符串模拟栈的操作。

时间复杂度：O(n) 空间复杂度：O(n)

● 代码实现

class Solution {
public:
    string removeDuplicates(string s) {
        stack<int> st;

        for(int i = 0; i < s.size(); i++)
        {
            if(st.empty() || st.top() != s[i])
            {
                st.push(s[i]);
            }
            else
            {
                st.pop();
            }
        }

        string res = "";
        while(!st.empty())
        {
            res += st.top();
            st.pop();
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

class Solution {
public:
    string removeDuplicates(string s) {
        string res = "";

        for(char s : s)
        {
            if(res.empty() || res.back() != s)
            {
                res.push_back(s);
            }
            else
            {
                res.pop_back();
            }
        }
        return res;
    }
};

● Leetcode150 逆波兰表达式求值

题目链接：Leetcode150 逆波兰表达式求值
视频讲解：代码随想录|逆波兰表达式求值
题目描述：给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。
注意：
有效的算符为 ‘+’、‘-’、‘*’ 和 ‘/’ 。
每个操作数（运算对象）都可以是一个整数或者另一个表达式。
两个整数之间的除法总是 向零截断 。
表达式中不含除零运算。
输入是一个根据逆波兰表示法表示的算术表达式。
答案及所有中间计算结果可以用 32 位 整数表示。

示例 1：
输入：tokens = [“2”,“1”,“+”,“3”,““]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
示例 2：
输入：tokens = [“4”,“13”,“5”,”/“,”+“]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
示例 3：
输入：tokens = [“10”,“6”,“9”,“3”,”+“,”-11","”,“/”,“*”,“17”,“+”,“5”,“+”]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

提示：
1 <= tokens.length <= 104
tokens[i] 是一个算符（“+”、“-”、“*” 或 “/”），或是在范围 [-200, 200] 内的一个整数

● 逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。
平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
逆波兰表达式主要有以下两个优点：
去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中。
逆波兰表达式相当于是二叉树中的后序遍历。

● 解题思路

本题依旧是处理相邻元素的问题，因此需要使用栈进行解决。
当我们遍历元素为数字时，直接放入栈中等待处理即可；当遍历元素为运算符时，就需要取栈内前两个元素进行运算后，再将其压入栈内留等之后的运算，直到栈内只剩最终结果时返回。
这里需要在运算符情况处理时注意，+, -, *不会对数字元素的顺序有所影响，但/的话必须是栈内第二个元素 / 栈内第一个元素，否则会导致无法成功。

时间复杂度：O(n) 空间复杂度：O(n)

● 代码实现

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> 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 res = st.top();
        st.pop();

        return res;
    }
};

● 总结

当遇到相邻元素进行处理，不管是消除还是匹配，使用栈的目的是可以获取遍历的前一个元素，从而进行处理。