剑指offer-栈与队列

剑指 Offer 09. 用两个栈实现队列

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

限制：

0 <= matrix.length <= 100

0 <= matrix[i].length <= 100

解题思路：
入队操作：照常给a添加元素 -> 时间：o(1)
出队操作：优先返回栈b顶元素，否则将栈a元素全部倒入栈b，再返回栈b顶元素 -> 时间：o(n)

class CQueue:
    def __init__(self): # 初始化
        self.stack1 = [] # 负责入栈（主栈）
        self.stack2 = [] # 负责出栈（辅助栈）

    def appendTail(self, value: int) -> None:
        self.stack1.append(value) # stack1常规添加元素 o(1)

    def deleteHead(self) -> int:
        if self.stack2: return self.stack2.pop() # check辅助栈，有则弹出栈2顶
        if not self.stack1: return -1 # 辅助栈空，check主栈是否空，返回-1
        while self.stack1: # 遍历主栈
            self.stack2.append(self.stack1.pop()) # 弹出主栈压入辅助栈，辅助栈顶为队列首元素
        return self.stack2.pop()

剑指 Offer 30. 包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例：

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.min();   --> 返回 -2.

提示：

各函数的调用总次数不超过 20000 次

普通栈的 push() 和 pop() 函数的复杂度为 O(1) ；而获取栈最小值 min() 函数需要遍历整个栈，复杂度为 O(N)。

解题思路：
push(x) 函数： 重点为保持栈 B 的元素是 非严格降序 的。

• 将 xx 压入栈 AA （即 A.add(x) ）；

• 若 ① 栈 B 为空 或 ② x 小于等于 栈 B 的栈顶元素，则将 x 压入栈 B （即 B.add(x) ）。
  pop() 函数： 重点为保持栈 A, B 的 元素一致性 。

• 执行栈 AA 出栈（即 A.pop() ），将出栈元素记为 yy ；

• 若 yy 等于栈 BB 的栈顶元素，则执行栈 B 出栈（即 B.pop() ）。
  top() 函数： 直接返回栈 AA 的栈顶元素即可，即返回 A.peek() 。

min() 函数： 直接返回栈 BB 的栈顶元素即可，即返回 B.peek() 。

class MinStack:
    def __init__(self):
        self.A = []  # 主栈
        self.B = []  # 辅助栈

    def push(self, x: int) -> None:
        self.A.append(x)  
        if not self.B or self.B[-1] >= x: 
            self.B.append(x)

    def pop(self) -> None:
        if self.A.pop() == self.B[-1]:
            self.B.pop()

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

    def min(self) -> int:
        return self.B[-1]