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

20. 有效的括号

题目：给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。有效字符串需满足：左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。注意空字符串可被认为是有效字符串。

由于栈结构的特殊性，非常适合做对称匹配类的题目。

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

1. 字符串里左方向的括号多余了 ，所以不匹配。

-> 已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false

2. 括号没有多余，但是 括号的类型没有匹配上。

-> 遍历字符串匹配的过程中，发现栈里没有要匹配的字符。所以return false

3. 字符串里右方向的括号多余了，所以不匹配。

-> 遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号return false

字符串遍历完之后，栈是空的，就说明全都匹配了。

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

代码如下：

class Solution(object):
    def isValid(self, s):
        if len(s) % 2 != 0: return False #可以先对奇数个判断一下，取模用%
        res = []
        for i in range(len(s)):
            if s[i] == '(': res.append(')')
            elif s[i] == '{': res.append('}')
            elif s[i] == '[': res.append(']')
            elif not res or res[-1] != s[i]: return False
            # elif s[i] != res[-1]: return False
            # elif not res: return False 这两行分开写会漏掉res一开始为空，索引失败报错
            else: res.pop()
        return True if not res else False

时间复杂度: O(n)

空间复杂度: O(n)

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

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

栈里应该放的是什么元素呢？

我们在删除相邻重复项的时候，其实就是要知道当前遍历的这个元素，我们在前一位是不是遍历过一样数值的元素，那么如何记录前面遍历过的元素呢？

所以就是用栈来存放，那么栈的目的，就是存放遍历过的元素，当遍历当前的这个元素的时候，去栈里看一下我们是不是遍历过相同数值的相邻元素。

然后再去做对应的消除操作。

从栈中弹出剩余元素，此时是字符串ac，因为从栈里弹出的元素是倒序的，所以再对字符串进行反转一下，就得到了最终的结果。

代码如下：

class Solution(object):
    def removeDuplicates(self, s):
        stack = []
        for st in s:
            if not stack or st != stack[-1]: stack.append(st)
            elif st == stack[-1]: stack.pop()
        # while not stack:
        #     res.append(stack.pop())
        return "".join(stack) #注意这里直接return字符串拼接就可以

时间复杂度: O(n)

空间复杂度: O(n)

150. 逆波兰表达式求值

题目：根据 逆波兰表示法，求表达式的值。有效的运算符包括 + ,  - ,  * ,  / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。逆波兰表达式：是一种后缀表达式，所谓后缀就是指运算符写在后面。

栈与递归之间在某种程度上是可以转换的

其实逆波兰表达式相当于是二叉树中的后序遍历。 可以把运算符作为中间节点，按照后序遍历的规则画出一个二叉树。

但我们没有必要从二叉树的角度去解决这个问题，只要知道逆波兰表达式是用后序遍历的方式把二叉树序列化了，就可以了。

在进一步看，本题中每一个子表达式要得出一个结果，然后拿这个结果再进行运算，那么这岂不就是一个相邻字符串消除的过程，和1047中的对对碰游戏非常像。

代码如下：

class Solution(object):
    def evalRPN(self, tokens):
        stack = []
        for st in tokens:
            if not stack or st not in {"+","-","*","/"}:
                stack.append(st)
            elif st == "+":
                num1 = int(stack.pop())
                num2 = int(stack.pop())
                stack.append(num2 + num1)
            elif st == "-":
                num1 = int(stack.pop())
                num2 = int(stack.pop())
                stack.append(num2 - num1)
            elif st == "*":
                num1 = int(stack.pop())
                num2 = int(stack.pop())
                stack.append(num2 * num1) 
            elif st == "/":
                num1 = float(stack.pop())
                num2 = float(stack.pop())
                stack.append(int(num2 / num1)) # 注意除法顺序，除法不能强制转换为int
        return int(stack.pop()) #不需要转化为字符串返回

时间复杂度: O(n)

空间复杂度: O(n)

python有更简便的函数实现方法：

from operator import add, sub, mul

class Solution:
    op_map = {'+': add, '-': sub, '*': mul, '/': lambda x, y: int(x / y)}
    
    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()

或者用eval：

 int(eval(f'{second_num} {item} {first_num}'))