栈和队列

1. 用栈实现队列

使用栈实现队列的下列操作：

push(x) -- 将一个元素放入队列的尾部。
pop() -- 从队列首部移除元素。
peek() -- 返回队列首部的元素。
empty() -- 返回队列是否为空。

class MyQueue:
    def __init__(self):
        self.s1 = []
        self.s2 = []
	
    # 添加元素到队尾
    def push(self, x: int) -> None: 
        self.s1.append(x)
        
    # 返回队头元素
    def peek(self) -> int:
        if not self.s2:  # s2 为空、s1 不为空时，弹出 s1 的元素并添加到 s2 中
            while self.s1:
                self.s2.append(self.s1.pop())
        return self.s2[-1]  # 返回 s2 最后的元素
	
    # 删除队头的元素并返回
    def pop(self) -> int:
        self.peek()  # 弹出元素之前，先调用 peek 保证 s2 中的元素不为空
        return self.s2.pop()

    # 判断队列是否为空
    def empty(self) -> bool:
        return not self.s1 and not self.s2  # 两个栈都为空，说明队列为空

2. 用队列实现栈

使用队列实现栈的下列操作：

push(x) -- 元素 x 入栈
pop() -- 移除栈顶元素
top() -- 获取栈顶元素
empty() -- 返回栈是否为空

class MyStack:
    def __init__(self):
        self.q = []

    def push(self, x: int) -> None:
        self.q.append(x)
        q_length = len(self.q)
        while q_length > 1:
            self.q.append(self.q.pop(0)) #反转前n-1个元素，栈顶元素始终保留在队首
            q_length -= 1

    def pop(self) -> int:
        return self.q.pop(0)
        
    def top(self) -> int:
        return self.q[0]

    def empty(self) -> bool:
        return not bool(self.q)

3. 最小值栈

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

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

class MinStack:
    def __init__(self):
        self.stack = []
        self.min_stack = [math.inf]

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

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

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

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

4. 用栈实现括号匹配

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

有效字符串需满足：

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

class Solution:
    def isValid(self, s: str) -> bool:
        if len(s) % 2 == 1: return False
        bracket = {"(": ")", "[": "]", "{": "}"}
        stack = []
        for i in s:
            if i in bracket:
                stack.append(i)
            else:
                if not stack or bracket[stack.pop()] != i:
                    return False
        return not stack

5. 数组中元素与下一个比它大的元组之间的距离

请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。

例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。

创建一个从上到下单调递增的栈 stack

class Solution:
    def dailyTemperatures(self, T: List[int]) -> List[int]:
        res = [0] * len(T)
        stack = []
        for i in range(len(T) - 1, -1, -1):
            while stack and T[stack[-1]] <= T[i]:
                stack.pop()
            if stack:
                res[i] = stack[-1] - i
            stack.append(i)
        return res

6. 循环数组中比当前元素大的下一个元素

给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。

输入: [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数； 
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        length = len(nums)
        res = [-1] * length
        stack = []
        # 假装这个数组的长度翻倍了
        for i in range(2 * length - 1, -1, -1):
            while stack and stack[-1] <= nums[i % length]:
                stack.pop()
            res[i % length] = -1 if not stack else stack[-1]
            stack.append(nums[i % length])
        return res