跟着leedcode刷算法 -- 堆、栈与队列4

这是我参与11月更文挑战的第17天，活动详情查看：2021最后一次更文挑战

题7

基本计算器 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:
        res = 0  
        stack = []
        sym = '+'
        for i in range(len(s)):
            ans = s[i]
            if ans.isdigit():
                res = res * 10 + int(ans)
            if ans in "+-*/" or i == len(s)-1:
                if sym == "+" :
                    stack.append(res)
                elif sym == "-" :
                    stack.append(-res)
                elif sym == "*":
                    stack.append(stack.pop() * res)
                else:
                    stack.append(int(stack.pop()/res))
                res = 0
                sym = ans
        return sum(stack)

执行结果：

题8

扁平化嵌套列表迭代器

给你一个嵌套的整数列表 nestedList 。每个元素要么是一个整数，要么是一个列表；该列表的元素也可能是整数或者是其他列表。请你实现一个迭代器将其扁平化，使之能够遍历这个列表中的所有整数。

实现扁平迭代器类 NestedIterator ：

NestedIterator(List nestedList) 用嵌套列表 nestedList 初始化迭代器。
int next() 返回嵌套列表的下一个整数。
boolean hasNext() 如果仍然存在待迭代的整数，返回 true ；否则，返回 false 。
你的代码将会用下述伪代码检测：

 initialize iterator with nestedList
 res = []
 while iterator.hasNext()
     append iterator.next() to the end of res
 return res

如果 res 与预期的扁平化列表匹配，那么你的代码将会被判为正确。

示例 1：

输入：nestedList = [[1,1],2,[1,1]]
输出：[1,1,2,1,1]
解释：通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,1,2,1,1]。 示例 2：
输入：nestedList = [1,[4,[6]]]
输出：[1,4,6]
解释：通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,4,6]。

提示：

1 <= nestedList.length <= 500
嵌套列表中的整数值在范围 [-106, 106] 内 相关标签
栈
树
深度优先搜索
设计
队列
迭代器

看到这样的题第一时间想到的是dfs 深度优先遍历

class NestedIterator:
    def __init__(self, nestedList: [NestedInteger]):
        self.stack = deque()
        self.dfs(nestedList)

    def dfs(self,nestedList):
        for row in nestedList:
            if row.isInteger():
                self.stack.append(row.getInteger())
            else:
                self.dfs(row.getList())
    
    def next(self) -> int:
        return self.stack.popleft()
        
    
    def hasNext(self) -> bool:
         return len(self.stack)

执行结果：

题9

逆波兰表达式求值

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

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

说明：

整数除法只保留整数部分。给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 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:
        self.stack = []
        for row in range(len(tokens)):
            try:
                self.stack.append(int(tokens[row]))
            except:
                if tokens[row] in ('+','-','*','/'):
                    b = self.stack.pop()
                    a = self.stack.pop()
                    if tokens[row] == '+':
                        self.stack.append(a + b)
                    elif tokens[row] == '-':
                        self.stack.append(a - b)
                    elif tokens[row] == '*':
                        self.stack.append(a * b)
                    elif tokens[row] == '/':
                        value = int(a / b)
                        self.stack.append(value)
        return self.stack[0]

执行结果：