Follow Carl To Grow|【LeetCode】20. 有效的括号，1047. 删除字符串中的所有相邻重复项，150. 逆波兰表达式求值-CSDN博客

本文链接：https://blog.csdn.net/hudy_/article/details/139033152

【LeetCode】20. 有效的括号

题意：给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

思路：相互匹配的符号一定是挨得最近的，利用栈的性质，遇到左边括号入栈，右边就出栈比较即可。

代码：

class Solution {
public:
    stack <char> stk;
    bool isValid(string s) {
        for (int i = 0; i < s.size(); ++i)
        {
            if(s[i] == '(' || s[i] == '[' || s[i] == '{')
            {
                stk.push(s[i]);
            }
            else
            {
                if (stk.empty())
                {
                    return false;
                }
                char c = stk.top();
                stk.pop();
                if (
                    (s[i] == ')' && c == '(')
                  ||(s[i] == ']' && c == '[')
                  ||(s[i] == '}' && c == '{'))
                  {
                    continue;
                  }
                else
                {
                    return false;
                }
            }
        }
        return stk.empty();
    }
};

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

题意：给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
在 S 上反复执行重复项删除操作，直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

思路：相邻重复项，考虑使用栈，每次判断栈顶和当前元素是否相同，相同则出栈，不同则入栈。最后构造出结果字符串，还要记得反转一下。

代码：

class Solution {
public:
    stack <char> stk;
    string removeDuplicates(string s) {
        for (int i = 0; i < s.size(); ++i)
        {
            if (stk.empty())
            {
                stk.push(s[i]);
                continue;
            }
            else
            {
                char c = stk.top();
                if (c == s[i])
                {
                    stk.pop();
                }
                else
                {
                    stk.push(s[i]);
                }
            }
        }
        string str;
        while (stk.size())
        {
            str += stk.top();
            stk.pop();
        }
        reverse(str.begin(), str.end());
        return str;
    }
};

【LeetCode】150. 逆波兰表达式求值

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

思路：同样利用栈，遇到数字就入栈，遇到符号就出栈，但是要注意左右操作数会反过来。

代码：

class Solution {
public:
    stack <long long> stk;
    int evalRPN(vector<string>& tokens) {
        for (int i = 0; i < tokens.size(); ++i)
        {
            if ("+" == tokens[i] || "-" == tokens[i] || "*" == tokens[i] || "/" == tokens[i])
            {
                long long right = stk.top();
                stk.pop();
                long long left = stk.top();
                stk.pop();
                if ("+" == tokens[i])
                {
                    stk.push(left + right);
                }
                else if ("-" == tokens[i])
                {
                    stk.push(left - right);
                }
                else if ("*" == tokens[i])
                {
                    stk.push(left * right);
                }
                else if ("/" == tokens[i])
                {
                    stk.push(left / right);
                }
            }
            else
            {
                stk.push(stoll(tokens[i]));
            }
        }
        long long res = stk.top();
        return res;
    }
};