leetcode面试题（第 13 -16 天）

1.0227. 基本计算器 II

1.1 题目大意

描述：给定一个字符串表达式 s，表达式中所有整数为非负整数，运算符只有 +、-、*、/，没有括号。

要求：实现一个基本计算器来计算并返回它的值。

这题的基本思路是用栈来记录之前出现的数字，具体实现是用preSign保存上一个运算符，用num保存当前数字，当遇到运算符时，就意味着要把num“结算一下”，如果preSign是加号，就将num直接压入栈，如果preSign是减号，就将-num压入栈，如果preSign是乘号，就将num和栈顶数字的乘积压入栈中，如果preSign是除号，就将栈顶数字和num的商压入栈中。循环结束，返回栈的和即可

class Solution:
    def calculate(self, s: str) -> int:
        n =len(s)
        num = 0
        preSign = '+'
        stack = []
        for i in range(n):
            if s[i]!= ' ' and  s[i].isdigit():
                num = num *10+ord(s[i])-ord('0')
            if i == n-1 or s[i] in '+-*/':
                if preSign == '+':
                    stack.append(num)
                elif preSign == '-':
                    stack.append(-num)
                elif preSign == '*':
                    stack.append(stack.pop()*num)
                else :
                    stack.append(int(stack.pop()/num))
                preSign = s[i]
                num = 0
        return sum(stack)



                

2.0232. 用栈实现队列

2.1 题目大意

要求：仅使用两个栈实现先入先出队列。

要求实现 MyQueue 类：

• void push(int x) 将元素 x 推到队列的末尾。
• int pop() 从队列的开头移除并返回元素。
• int peek() 返回队列开头的元素。
• boolean empty() 如果队列为空，返回 True；否则，返回 False。

说明：

• 只能使用标准的栈操作 —— 也就是只有 push to top, peek / pop from top, size, 和 is empty 操作是合法的。
• 可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
• 1<=x<=9。
• 最多调用 100 次 push、pop、peek 和 empty。
• 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）。
• 进阶：实现每个操作均摊时间复杂度为 O(1) 的队列。换句话说，执行 n 个操作的总时间复杂度为 O(n)，即使其中一个操作可能花费较长时间。

示例：

• 示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

 输出栈和输入栈是同一个容器的两部分，入队则往输出栈里加，出队因为要把最早进队的元素拎出来，所以要把输入栈的元素搬空，取输出栈的栈顶。

class Solution:
    def calculate(self, s: str) -> int:
        n =len(s)
        num = 0
        preSign = '+'
        stack = []
        for i in range(n):
            if s[i]!= ' ' and  s[i].isdigit():
                num = num *10+ord(s[i])-ord('0')
            if i == n-1 or s[i] in '+-*/':
                if preSign == '+':
                    stack.append(num)
                elif preSign == '-':
                    stack.append(-num)
                elif preSign == '*':
                    stack.append(stack.pop()*num)
                else :
                    stack.append(int(stack.pop()/num))
                preSign = s[i]
                num = 0
        return sum(stack)



                

3.0394. 字符串解码

3.1 题目大意

描述：给定一个经过编码的字符串 s。

要求：返回 s 经过解码之后的字符串。

说明：

• 编码规则：k[encoded_string]。encoded_string 为字符串，k 为整数。表示字符串 encoded_string 重复 k 次。

示例：

• 示例 1：

输入：s = "3[a]2[bc]"
输出："aaabcbc"Copy to clipboardErrorCopied

• 示例 2：

输入：s = "3[a2[c]]"
输出："accaccacc"

 因为会出现括号嵌套，所以肯定得用栈。比较难理解的是当是右括号时‘ 】’，是从栈中读支配当前括号的倍数last_multi，然后乘以倍数后的当前字符串last_multi*res和栈中记录的老字符串last_res拼接；当是左括号时‘ 【’，入栈并初始化；当是数字时则将字符数字化；当是字符时则将字符加进当前字符串中。

class Solution:
    def decodeString(self, s: str) -> str:
        stack,multi,res = [],0,""
        for c in s:
            if c == '[':
                stack.append([multi,res])
                multi,res = 0,""
            elif c == ']':
                last_multi,last_res = stack.pop()
                res = last_res+res*last_multi
            elif '0' <= c <= '9':
                multi = multi*10+int(c)
            else:
                res += c

                
            
        return  res