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

20. 有效的括号

题目：

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

有效字符串需满足：

左括号必须用相同类型的右括号闭合。

左括号必须以正确的顺序闭合。

每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = "()"

输出：true

示例 2：

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

输出：true

示例 3：

输入：s = "(]"

输出：false

代码：

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []  # 新建一个栈

        for item in s:  # 遍历输入的字符串
            if item == '(':
                stack.append(')')
            elif item=='[':
                stack.append(']')
            elif item=='{':
                stack.append('}')
            elif not stack or stack[-1]!=item:   # 如果栈为空or当前的元素不是栈顶的元素
                return False
            else:
                stack.pop()   # 如果当前右括号和栈顶元素匹配，则移除它，继续遍历后面的。
        if not stack:
            return True
        else:
            return False

总结：

1、确认3种不成立的情况；

2、分别加入到栈中，需要学习模拟。

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

题目：

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

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

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

示例：

输入："abbaca"

输出："ca"

解释：

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

代码：

class Solution:
    def removeDuplicates(self, s: str) -> str:
        stack = []  # 创建栈
        for i in s:
            if stack and stack[-1] == i:  # 如果栈不为空，且栈顶等于从s中取出的数
                stack.pop()  # 默认移除列表中的最后一个元素
            else:
                stack.append(i)  # 如果相邻的字符不相等，则放进栈里
            return ''.join(i)  # 把列表转为字符串
                

思路：字符串本身就是一个数据容器，新建一个栈用来接收遍历的字符。 

150. 逆波兰表达式求值

题目：

给你一个字符串数组 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

代码：

from operator import add, sub, mul


class Solution:
    op_map = {'+': add, '-': sub, '*': mul, '/': lambda x, y: int(x / y)}  # 引入operator模块  作为字典，存储运算符

    def evalRPN(self, tokens: List[str]) -> int:
        stack = []
        for token in tokens:  # 遍历输入的字符串
            if token not in {'+', '-', '*', '/'}:
                stack.append(int(token))
            else:
                op2 = stack.pop()
                op1 = stack.pop()
                stack.append(self.op_map[token](op1, op2))   # 根据当前遍历到的运算符计算最近的两个数字，这一步很重要
        return stack.pop()   # 弹出栈顶元素，也就是计算到最后的数值。

思路：

第一遍完全看不懂。

看了视频和文字讲解，就很通透了，对于栈能解决的问题也更加深刻。

但是还是有一部分看不懂或者还需要再消化的。比如op_map的字典。