刷题第十天 20. 有效的括号 1047.删除字符串中所有相邻字符 150. 逆波兰表达式

20. 有效的括号

class Solution(object):
    def isValid(self, s):
        _list = []
        size = 0
        for i in s:
            if i == '(' or i == '[' or i == '{':
                _list.append(i)
                size = size + 1
            if i == ')':
                if size == 0:
                    return False
                pop = _list[-1]
                if pop != '(':
                    return False
                else:
                    _list.pop()
                    size -= 1
            if i == ']':
                if size == 0:
                    return False                
                pop = _list[-1]
                if pop != '[':
                    return False
                else:
                    _list.pop()
                    size -= 1
            if i == '}':
                if size == 0:
                    return False
                pop = _list[-1]
                if pop != '{':
                    return False
                else:
                    _list.pop()
                    size -= 1
        if size == 0:
            return True
        else:
            return False

有效括号，针对题目要求设计不同情况的判断，利用栈先进后出的思想

看了题解之后发现可以利用括号互逆的性质，如果判断是左括号，就压栈右括号，这样可以少一个判断。

1047. 删除字符串中所有相邻字符

class Solution(object):
    def removeDuplicates(self, s):
        stack = []
        for val in s:
            if not stack:
                stack.append(val)
            elif stack[-1] != val:
                stack.append(val)
            else:
                stack.pop()
        return ''.join(stack)

依次压栈，如果碰到相同的就pop()

150. 逆波兰表达式

class Solution(object):
    def evalRPN(self, tokens):
        stack = []
        for val in tokens:
            if val not in ['+', '-', '*', '/']:
                stack.append(val)
            else:
                a = stack.pop()
                b = stack.pop()
                expression = 'int(' + str(b) + val + str(a) + ')'
                stack.append(eval(expression))
        return int(stack.pop())

依次压栈，如果碰到运算符就pop两个 做完运算之后压栈

写完半天都没有AC 仔细检查发现python2 和python3 对于取整是不一样的

python2中 如果用 / 进行除法，如果前后都是整数，会自动进行整数除法并向下取整，而不是向零取整 比如1/-10 = -0.1 向下取整为 -1

python3中 用/进行除法，会默认进行浮点数除法 1/-10 = -0.1 如果int(0.1)是向0 取整 为0

所以

python2中 int(1/-10) = int(-1) = -1

python3中 int(1/-10) = int(-0.1) = 0