2024/3/13--代码随想录算法训练营day11|20.有效的括号、1047.删除字符串中的所有相邻重复项、150.逆波兰表达式求值

list（）可以添加元素append()\移除元素pop()\栈顶 list[-1]
python一个初始化的list，永远不可能是None 可以用not list 或者len(list) == 0 检查是否为空

【stack.pop()和stack[-1]的区别：
1.pop()能返回栈顶元素并移除
2.stack[-1]仅仅返回栈顶元素】
eval(f’{op2}{i}{op1}')

20.有效的括号

力扣链接

明白那些情况不：
1.左括号多了
2.右括号多了，包括 这种 ）（
3.括号不匹配 【{】}这种也是不匹配！

遇到左括号，就往栈里面，放对应的右括号 ；遇到右括号，就去删栈顶元素；
如果不匹配，或者匹配时栈为空，或者匹配结束，栈里还有都是不匹配

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:  #针对1.不匹配  2.右括号多了
                return False
            else:   #如果栈顶和item一样，就移除栈顶
                stack.pop()
        return True if not stack else False   #3.针对左括号多了

# 方法二，使用字典
class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        mapping = {
            '(': ')',
            '[': ']',
            '{': '}'
        }
        for item in s:
            if item in mapping.keys(): #也可以直接用 if item in mapping:
                stack.append(mapping[item])
            elif not stack or stack[-1] != item: 
                return False
            else: 
                stack.pop()
        return True if not stack else False

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

力扣链接

匹配问题：删除重复项时，需要知道当前遍历的元素，前一步是不是也遍历过一样值的元素，所以需要用栈来记录遍历过的元素。

【在第一次写代码时，犯了错误，stack and stack[-1]是为了stack.pop()的时候，可以吐出。
                            其次栈为空，或者栈顶元素不匹配，都要添加item】
                            
方法一：使用栈
class Solution:
    def removeDuplicates(self, s: str) -> str:
        stack = []
        for i in s:
            if stack and i == stack[-1]:
                stack.pop()
            else:
                stack.append(i)
        return ''.join(stack)

# 方法二，使用双指针模拟栈，如果不让用栈可以作为备选方法。【第一轮没看明白】
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.逆波兰表达式求值

力扣链接

遇到数字就入栈，遇到运算符则去除栈顶的两个数字进行计算，将计算结果压入栈中

方法一，仅使用栈，更省空间
from operator import add,sub,mul
class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        map = {"+":add, "-":sub, "*":mul,  "/":lambda x,y :int(x/y)}    ##!!!这个很重要，会写，本题成功 80%
        stack = []
        for i in tokens:
            if i not in map:
                stack.append(int(i))   #str转换成int
            else :
                op1 = stack.pop()   
                op2 = stack.pop()
                stack.append( map[i](op2,op1) )  #注意运算顺序，op1是除数 ，op2是被除数
        return stack.pop()

方法二，但因为使用eval相对较慢的方法
class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        stack = []
        for i in tokens:
            if i not in ["+","-","*","/"]:
                stack.append(int(i))
            else :
                op1,op2 = stack.pop(),stack.pop()
                stack.append(
                    int(eval(f'{op2}{i}{op1}'))   #eval返回的结果类型取决于表达式本身，但是结果都是整数
                    )
        return stack.pop()