LeetCode 20有效的括号 1047删除字符串中的所有相邻重复项 150 逆波兰表达式求值

20.有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
3. 每个右括号都有一个对应的相同类型的左括号。

示例1：

输入：s = "()"
输出：true

示例2：

输入：s = "()[]{}"
输出：true

示例3：

输入：s = "(]"
输出：false

提示：

• 1 <= s.length <= 104
• s 仅由括号 '()[]{}' 组成

c++ 代码实现

class Solution {
public:
    bool isValid(string s) {
        // 判断是否两两相对
        int n = s.size();
        if (n % 2 == 1) {
            return false;
        }

        // 括号匹配
        unordered_map<char, char> pair = {
            { ')', '(' },
            { '}', '{' },
            { ']', '[' }
        };

        // 利用栈后进先出，匹配
        stack<char> sta;
        for (char ch: s) {
            // 是否已找到右边的键
            if (pair.count(ch)) {
                // 判断栈是否为空，第一个是否等于键值，返回false
                if (sta.empty() || sta.top() != pair[ch]) {
                    return false;
                }
                // 删除
                sta.pop();
            }else{
                // 压入栈
                sta.push(ch);
            }
        }
        // 是否为空，返回
        return sta.empty();
    }
};

python 代码实现

class Solution:
    def isValid(self, s: str) -> bool:
        sList = list(s)
        n = len(sList)
        if n % 2 == 1:
            return False

        # 挂号匹配
        pair = {
            ')': '(' ,
            ']': '[' ,
            '}': '{'
        }

        # 栈
        stack = list()
        for i in range(n):
            ch = sList[i]
            if ch in pair:
                if not stack or stack[-1] != pair[ch]:
                    return False
                stack.pop()
            else:
                stack.append(ch)
                
        return not stack

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

题目

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：

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

提示：

• 1 <= S.length <= 20000
• S 仅由小写英文字母组成。

c++代码实现

class Solution {
public:
    string removeDuplicates(string s) {
        int n = s.size();
        if (n < 2) return s;
        string newStr = "";

        for (char ch: s) {
            // 拿最后一个对比
            if (newStr != "" && newStr.back() == ch) {
                //两个相邻且相同的字母
                newStr.pop_back();
            }else{
                // 字符串往后压入
                newStr.push_back(ch);
            }
        }
        return newStr;
    }
};

python代码实现

class Solution:
    def removeDuplicates(self, s: str) -> str:
        sList = list(s)
        n = len(sList)
        newStr = []
        for i in range(n):
            ch = sList[i]
            if len(newStr) !=0 and newStr[-1] == ch:
                newStr.pop()
            else:
                newStr.append(ch)
        return ''.join(newStr)

150逆波兰表达式求值

根据 逆波兰表示法，求表达式的值。

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

注意 两个整数之间的除法只保留整数部分。

可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例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 + * 也可以依据次序计算出正确结果。
• 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

c++ 代码实现

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        int n = tokens.size();
        stack<int> sta;
        for (int i = 0; i < n; i++) {
            string num = tokens[i];
            // 如果不是 + - * / 数字压入栈
            if(num != "+" && num != "-" && num != "*" && num != "/") {
                sta.push(stol(num));
            } else {
                // 一旦遇到 + - * / 运算符，计算两者运算。
                int num2 = sta.top();
                // 删除
                sta.pop();
                int num1 = sta.top();
                sta.pop();

                // 运算符只有一位
                switch (num[0]) {
                    case '+': sta.push(num1 + num2); break;
                    case '-': sta.push(num1 - num2); break;
                    case '*': sta.push(num1 * num2); break;
                    case '/': sta.push(num1 / num2); break;
                }
            }
        }
        return sta.top();
    }
};

python 代码实现

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        n = len(tokens)
        sta = list()
        for i in range(n):
            ch = tokens[i]
            if (ch != "+" and ch != "-" and ch != "*" and ch != "/"):
                sta.append(int(ch))
            else:
                num2 = sta[-1]
                sta.pop()
                num1 = sta[-1]
                sta.pop()

                if ch == "+":
                    sta.append(num1 + num2)
                if ch == "-":
                    sta.append(num1 - num2)
                if ch == "*":
                    sta.append(num1 * num2)
                if ch == "/":
                    # 这里注意，只保留整数
                    sta.append(int(num1 / num2))
                
        return sta[-1]