leetcode基础编程：栈

19. 有效的括号

难度：简单

收藏

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

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

示例 4：

输入：s = "([)]"
输出：false

示例 5：

输入：s = "{[]}"
输出：true

提示：

• 1 <= s.length <= 104
• s 仅由括号 '()[]{}' 组成

class Solution:
    def isValid(self, s: str) -> bool:
        stk=[]
        for c in s:
            if c=='(' or c=='[' or c=='{':
                stk.append(c)
            elif len(stk) and abs(ord(stk[-1])-ord(c))<=2: #这一句需要了解[]{}()他们每组ascii码相差
                stk=stk[:-1]
            else:
                return False
        return not len(stk)

126. 逆波兰表达式求值

难度：中等

收藏

根据 逆波兰表示法，求表达式的值。

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

注意 两个整数之间的除法只保留整数部分。

可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：

输入：tokens = ["4","13","5","/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

示例 3：

输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

提示：

• 1 <= tokens.length <= 104
• tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

• 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
• 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

• 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + *也可以依据次序计算出正确结果。
• 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

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

130. 最小栈

难度：简单

收藏

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

• push(x) —— 将元素 x 推入栈中。
• pop() —— 删除栈顶的元素。
• top() —— 获取栈顶元素。
• getMin() —— 检索栈中的最小元素。

示例:

输入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

输出：
[null,null,null,null,-3,null,0,-2]

解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.

提示：

• pop、top 和 getMin 操作总是在 非空栈 上调用。

class MinStack:
    def __init__(self):
        self.stackValue=[]
        self.stackMin=[]
    

    def push(self, val: int) -> None:
        self.stackValue.append(val)
        if not len(self.stackMin) or self.stackMin[-1] >=val:
            self.stackMin.append(val)


    def pop(self) -> None:
        if self.stackMin[-1]==self.stackValue[-1]:
            self.stackMin=self.stackMin[:-1]   
        self.stackValue=self.stackValue[:-1]


    def top(self) -> int:
        return self.stackValue[-1]


    def getMin(self) -> int:
        return self.stackMin[-1]



# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(val)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

387. 比较含退格的字符串

难度：简单

收藏

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，请你判断二者是否相等。# 代表退格字符。

如果相等，返回 true ；否则，返回 false 。

**注意：**如果对空文本输入退格字符，文本继续为空。

示例 1：

输入：s = "ab#c", t = "ad#c"
输出：true
解释：S 和 T 都会变成 “ac”。

示例 2：

输入：s = "ab##", t = "c#d#"
输出：true
解释：s 和 t 都会变成 “”。

示例 3：

输入：s = "a##c", t = "#a#c"
输出：true
解释：s 和 t 都会变成 “c”。

示例 4：

输入：s = "a#c", t = "b"
输出：false
解释：s 会变成 “c”，但 t 仍然是 “b”。

提示：

• 1 <= s.length, t.length <= 200
• s 和 t 只含有小写字母以及字符 '#'

进阶：

• 你可以用 O(N) 的时间复杂度和 O(1) 的空间复杂度解决该问题吗？

def get(s:str)->str:
    res=''
    for c in s:
        if c=='#':
            if len(res):
                res=res[:-1]
        else:
            res+=c
    return res
class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        return get(s) == get(t)

167. 基本计算器 II

难度：中等

收藏

给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。

整数除法仅保留整数部分。

示例 1：

输入：s = "3+2*2"
输出：7

示例 2：

输入：s = " 3/2 "
输出：1

示例 3：

输入：s = " 3+5 / 2 "
输出：5

提示：

• 1 <= s.length <= 3 * 105
• s 由整数和算符 ('+', '-', '*', '/') 组成，中间由一些空格隔开
• s 表示一个 有效表达式
• 表达式中的所有整数都是非负整数，且在范围 [0, 231 - 1] 内
• 题目数据保证答案是一个 32-bit 整数

法一：简单粗暴

class Solution:
    def calculate(self, s: str) -> int:
        s=s.replace('/','//')
        return eval(s)

法二：正儿八经

num=[]
op=[]
dig=[chr(i) for i in range(ord('0'),ord('9')+1)]
def eval0(num,op):
    b=num[-1]
    num=num[:-1]
    a=num[-1]
    num=num[:-1]
    c=op[-1]
    op=op[:-1]
    if c=='+':
        r=a+b
    elif c=='-':
        r=a-b
    elif c=='*':
        r=a*b
    elif c=='/':
        r=a//b
    num.append(r)
    return num,op
class Solution:
    def calculate(self,s: str) -> int:
        global num
        global op
        pr={}
        pr['+']=pr['-']=1
        pr['*']=pr['/']=2
        i = 0
        while i < len(s):
            c = s[i]
            if c==' ':
                i+=1
                continue
            if c in dig:
                x = 0
                j = i
                while j<len(s) and (s[j] in dig):
                    x = x*10 + int(s[j])
                    j+=1
                #print(x)
                num.append(x)
                i=j-1
                #print("i=",end='')
                #print(i)
            else:
                while op and pr[op[-1]]>=pr[c]:
                    #print('ok')
                    num,op=eval0(num,op)
                op.append(c)
            i+=1
        #print(num,op)
        while op:
            num,op=eval0(num,op)
        return num[-1]