代码随想录算法训练营Day11 | 20. 有效的括号、1047. 删除字符串中的所有相邻重复项、150. 逆波兰表达式求值 | Python | 个人记录向

20. 有效的括号

代码随想录：20. 有效的括号
Leetcode：20. 有效的括号

做题

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        for char in s:
            if char == '(' or char == '{' or char == '[':
                stack.append(char)
            elif len(stack) > 0:
                if char == ')' and stack[-1] == '(':
                    stack.pop()
                elif char == '}' and stack[-1] == '{':
                    stack.pop()
                elif char == ']' and stack[-1] == '[':
                    stack.pop()
                else:
                    return False
            else:
                return False
        if len(stack) == 0:
            return True
        else:
            return 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:
                return False
            else:
                stack.pop()
        
        return True if not stack else False

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

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

代码随想录：1047. 删除字符串中的所有相邻重复项
Leetcode：1047. 删除字符串中的所有相邻重复项

做题

思路比较简单，并使用了python的合并字符串操作。

class Solution:
    def removeDuplicates(self, s: str) -> str:
        stack = []
        for char in s:
            if len(stack) > 0 and stack[-1] == char:
                stack.pop()
            else:
                stack.append(char)
        return ''.join(stack)

时间复杂度: O(n)
空间复杂度: O(1)

看文章

文章的python解法也是用了合并字符串的功能，虽然我觉得这不算是栈的特性，而是python的特性。也可以用双指针，代码如下：

class Solution:
    def removeDuplicates(self, s: str) -> str:
        res = list(s)
        slow = fast = 0
        length = len(res)

        while fast < length:
            # 如果一样直接换，不一样会把后面的填在slow的位置
            res[slow] = res[fast]
            
            # 如果发现和前一个一样，就退一格指针
            if slow > 0 and res[slow] == res[slow - 1]:
                slow -= 1
            else:
                slow += 1
            fast += 1
            
        return ''.join(res[0: slow])

150. 逆波兰表达式求值

代码随想录：150. 逆波兰表达式求值
Leetcode：150. 逆波兰表达式求值

做题

思路总体是对的。一开始忘了isdigit()，但使用仍然报错，发现isdigit()函数只能判断0-9的数字。另一方面，题目要求的向零截断一开始没看懂，以为不能有负数，实际上是不保留小数点之后的数（最终结果和中间结果都是这个要求）。

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        stack = []
        for token in tokens:
            if token not in ['+', '-', '*', '/']:
                stack.append(int(token))
            else:
                b = stack.pop()
                a = stack.pop()
                if token == '+':
                    c = a + b
                    stack.append(c)
                elif token == '-':
                    c = a - b
                    stack.append(c)
                elif token == '*':
                    c = a * b
                    stack.append(c)
                elif token == '/':
                    c = int(a / b)
                    stack.append(c)
        return stack[-1]

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

看文章

思路是一致的，只是在识别运算符时，使用了特殊的函数。

使用operator函数

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

eval函数相对较慢

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        stack = []
        for item in tokens:
            if item not in {"+", "-", "*", "/"}:
                stack.append(item)
            else:
                first_num, second_num = stack.pop(), stack.pop()
                stack.append(
                    int(eval(f'{second_num} {item} {first_num}'))
                )
        return int(stack.pop()) # 如果一开始只有一个数，那么会是字符串形式的

以往忽略的知识点小结

• 判断数字的函数isdigit()只能判断一个字符。
• 向零截断的意思是，直接去掉小数点之后的数，直接用int()即可。
• 了解operator函数。
• 了解eval函数。

个人体会

完成时间：1h20min。
心得：栈比较熟悉，思路基本没问题，多了解一些库函数。

​