Leetcode 0155.最小栈 0844.比较含退格的字符串 0227.基本计算器II

---

0155.最小栈

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

实现 MinStack 类:

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

思路：
维持多一个mins数组即可实现常数时间内检索到最小元素的栈了。

class MinStack:

    def __init__(self):
        self.stack = []
        self.mins = [10**10]

    def push(self, val: int) -> None:
        self.stack.append(val)
        self.mins.append(min(self.mins[-1],val))


    def pop(self) -> None:
        self.stack.pop()
        self.mins.pop()


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


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

0844.比较含退格的字符串

题目：
给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

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

思路：
这里可以将字符串建模成栈的形式，遇到#就出栈。这里要注意对空文本进行退格时，文本依然为空，但此时对空数组进行pop操作会报错。

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        self.stack1 = []
        self.stack2 = []
        for s1 in s:
            if s1 != '#':
                self.stack1.append(s1)
            else:
                if self.stack1 != []:
                    self.stack1.pop()
        for t1 in t:
            if t1 != '#':
                self.stack2.append(t1)
            else:
                if self.stack2 != []:
                    self.stack2.pop()
        return self.stack1 == self.stack2

0227.基本计算器II

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

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

思路：
这种中缀表达式，比较难处理，不像逆波兰表达式，直接入栈即可。

在这道题中，需要保证*/的优先级，因此，需要先遍历一遍，计算乘除，结果入栈，最后再进行相加。

class Solution:
    def calculate(self, s: str) -> int:
        size = len(s)
        op = '+'
        stack = []
        index = 0
        while index < size:
            if s[index] == ' ':
                index += 1
                continue
            if s[index].isdigit():
                num = int(s[index])
                while index + 1 < size and s[index + 1].isdigit():
                    index += 1
                    num = num * 10 + int(s[index]) 
                if op == '+':
                    stack.append(num)
                elif op == '-':
                    stack.append(-num)
                elif op == '*':
                    stack.append(stack.pop()*num)
                elif op == '/':
                    stack.append(int(stack.pop()/num))
            elif s[index] in "+-*/":
                op = s[index]
            index += 1
        return sum(stack)