力扣刷题0708

20. 有效的括号

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

有效字符串需满足：

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

题目链接：链接

自己理解题目：首先想着用两个列表分别添加左右括号，然后依次弹出，判断是否配对，写出代码但不能通过全部测试用例。

class Solution:
    def isValid(self, s: str) -> bool:
        
        dic={"(":")","{":"}","[":"]"}
        res=[]
        ans=[]
        if len(s)%2!=0:
            return False
        for i in s:
            if i in dic.keys():
                ans.append(i)
            if i in dic.values():
                res.append(i)
                if len(ans)!=0 and dic[ans.pop()]==i:
                    continue
                else:
                    return False
            if len(res)==len(s) or len(ans)==len(s):
                return False
        return True

看了视频链接自己改写后得到：

class Solution:
    def isValid(self, s: str) -> bool:
        
        dic={"(":")","{":"}","[":"]"}
        res=[]
        ans=[]
        if len(s)%2!=0:
            return False
        for i in s:
            if i in dic.keys():
                ans.append(dic[i])
            if i in dic.values():
                if len(ans)==0 or ans.pop(-1)!=i:
                    return False
        if len(ans)!=0:
            return False
        return True

参考答案：链接

# 方法一，仅使用栈，更省空间
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

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

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

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

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

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

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

题目链接：链接

自己理解题目：第一想法是定义一个函数，查找字符串中的相邻的相等字符，然后删除，返回自己调用自己的返回值，主函数中调用这个函数即可。

def rm(s):
            n=0
            while n<(len(s)-2):
                for i in range(n+1,len(s)-1):
                    if s[n]==s[i]:
                        j=i+1
                        s=s[:n]+s[j:]
                n+=1
            return rm(s)
        rm(s)

看了答案修改后通过

class Solution:
    def removeDuplicates(self, s: str) -> str:
        l=[]
        n=0
        while n<len(s):
            if l and l[-1]==s[n]:
                l.pop()
            else:
                l.append(s[n])
            n+=1
        return "".join(l)

参考答案：

# 方法一，使用栈
class Solution:
    def removeDuplicates(self, s: str) -> str:
        res = list()
        for item in s:
            if res and res[-1] == item:
                res.pop()
            else:
                res.append(item)
        return "".join(res)  # 字符串拼接

# 方法二，使用双指针模拟栈，如果不让用栈可以作为备选方法。
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]#以输入abbaca为例，此时slow和fast都指向第二个b，
            
            # 如果发现和前一个一样，就退一格指针
            if slow > 0 and res[slow] == res[slow - 1]:
                slow -= 1#发现前一个相同时，slow后退到第一个b
            else:
                slow += 1
            fast += 1#fast仍向前指向至第二个a
            
        return ''.join(res[0: slow])

反思总结：双指针法还是没有很明白，还要加油学习

150. 逆波兰表达式求值

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

题目链接：链接

自己理解题目：逆波兰表达式是啥？？？后缀表达式。。。二叉树的后序遍历，计算机用后缀表达式可以更快的解决算术问题。

参考答案：

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()

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()) # 如果一开始只有一个数，那么会是字符串形式的

反思总结：思路是会了，加减乘除加载的模块不知道。。。