代码随想录day11 栈和队列（2）

20. 有效的括号 - 力扣（LeetCode）

一开始漏了存在多余左括号的情况：应该在遍历结束后检查que是否为空，若不为空则存在多余左括号。

栈que仅保存左括号，一旦遇到匹配的右括号，最后入栈的左括号弹出。三个return False分别对应：栈中没有左括号就遇到了右括号；左右括号不是同类的括号；栈中有剩余的左括号但已没有右括号。若这些情况都不符合，就是有效的括号字符串。

class Solution(object):
    def isValid(self, s):
        from collections import deque
        que = deque()
        for ch in s:
            if ch in ['(', '{', '[']:
                que.append(ch)
            else:
                if not que:
                    return False
                cur = que.pop()
                if not self.valid(cur, ch):
                    return False
        
        if que:
            return False
        
        return True
    
    def valid(self, cur, ch):
        f1 = cur == '(' and ch ==')'
        f2 = cur == '[' and ch == ']'
        f3 = cur == '{' and ch == '}'
        return f1 or f2 or f3 

1047. 删除字符串中的所有相邻重复项 - 力扣（LeetCode） 

解法一：用栈，时间O(n)，空间O(1)（事实上空间为res的大小

class Solution(object):
    def removeDuplicates(self, s):
        res = []
        for ch in s:
            if res:
                if res[-1] == ch:
                    res.pop()
                else:
                    res.append(ch)
            else:
                res.append(ch)
        
        return "".join(c for c in res)

 解法二：虽然逻辑上直观但细节很复杂，容易错，最后也因为超时没有跑通所有测试用例（104/106）

空间O(n)；时间：每次调用getNext都是O(n)，每次调用结果是将当前字符串相邻重复字母消除，如"abba"变为"aa"，而"aa"的消除要等到下一次调用。调用次数由测试用例决定，因此较复杂的用例会超时。

#通过用例104/106，超出时间限制
class Solution(object):
    def removeDuplicates(self, s):
        next = [i+1 for i in range(len(s))]
        next[-1] = -1
        next.append(0)
        flag = True
        while flag:
            next, flag = self.getNext(s, next)

        res = ""
        i = next[len(s)]
        while i != -1:
            res += s[i]
            i = next[i]    

        return res

    def getNext(self, s, next):
        flag = False
        anchor = len(s)
        while anchor != -1 and next[anchor] != -1 and next[next[anchor]] != -1:
            probe = next[anchor]
            val = s[probe]

            if s[next[probe]] == val:
                flag = True
                """
                #如果题目要求删去所有相接且相同的元素，而不只是删去相邻的元素：
                while s[next[probe]] == val and probe != -1 and next[probe] != -1:
                    probe = next[probe]
                probe = next[probe]
                """
                next[anchor] = next[next[probe]]

            else:
                anchor = probe

        return next, flag

 

150. 逆波兰表达式求值 - 力扣（LeetCode）

易错的是除法。python3中的"//"是向下整除，对于异号的除法，结果为负数，向下取整就不是题目要求的向零取整。需要先做小数除法"/"，再转为int，此时取结果的整数部分，相当于向零取整。

class Solution(object):
    def evalRPN(self, tokens):
        stack = []

        for t in tokens:
            if t not in ["/", "*", "+", "-"]:
                stack.append(int(t))

            else:
                b = stack.pop()
                a = stack.pop()
                if t == "+":
                    stack.append(a + b)
                if t == "-":
                    stack.append(a - b)
                if t == "*":
                    stack.append(a * b)
                if t == "/":
                    stack.append(int(a / b))
        
        return stack[0]