栈题目：最小栈

题目

标题和出处

标题：最小栈

出处：155. 最小栈

难度

4 级

题目描述

要求

设计一个支持入栈、出栈、查看栈顶元素操作，并能在常数时间内检索到最小元素的栈。

实现 $\text{MinStack}$ 类：

• $\text{MinStack()}$ 初始化栈对象。
• $\text{void push(val)}$ 将元素 $\text{val}$ 入栈。
• $\text{void pop()}$ 删除栈顶的元素。
• $\text{int top()}$ 获取栈顶元素。
• $\text{int getMin()}$ 检索栈内的最小元素。

示例

示例 1：

输入：
$\text{["MinStack","push","push","push","getMin","pop","top","getMin"]}$
$\text{[[],[-2],[0],[-3],[],[],[],[]]}$
输出：
$\text{[null,null,null,null,-3,null,0,-2]}$
解释：
$\text{MinStack minStack = new MinStack();}$
$\text{minStack.push(-2);}$
$\text{minStack.push(0);}$
$\text{minStack.push(-3);}$
$\text{minStack.getMin();}$ // 返回 $\text{-3}$
$\text{minStack.pop();}$
$\text{minStack.top();}$ // 返回 $\text{0}$
$\text{minStack.getMin();}$ // 返回 $\text{-2}$

数据范围

• ${\text{-2}}^{\text{31}}\le \text{val}\le {\text{2}}^{\text{31}}-\text{1}$
• 方法 $\text{pop}$、$\text{top}$ 和 $\text{getMin}$ 总是在非空栈上调用
• 最多调用 $\text{3}\times {\text{10}}^{\text{4}}$ 次 $\text{push}$、$\text{pop}$、$\text{top}$ 和 $\text{getMin}$

解法

思路和算法

最小栈需要支持常规栈的操作，另外还要在常数时间内检索到最小元素。为了支持常规栈的操作，需要维护一个常规栈。为了在常数时间内检索到最小元素，需要维护一个最小元素栈，最小元素栈的栈顶元素为最小元素。常规栈和最小元素栈分别为 $\text{stack}$ 和 $\text{minStack}$。

对于 $\text{push}$ 方法，进行如下操作：

• 将元素 $\text{val}$ 入栈 $\text{stack}$；

• 如果 $\text{minStack}$ 为空或者 $\text{val}$ 小于等于 $\text{minStack}$ 的栈顶元素，则 $\text{val}$ 是最小元素，将 $\text{val}$ 入栈 $\text{minStack}$。

对于 $\text{pop}$ 方法，进行如下操作：

• 将 $\text{stack}$ 的栈顶元素出栈，记为 $\text{val}$；

• 如果 $\text{val}$ 和 $\text{minStack}$ 的栈顶元素相等，则出栈的元素是最小元素，将 $\text{minStack}$ 的栈顶元素出栈。

对于 $\text{top}$ 方法，返回 $\text{stack}$ 的栈顶元素。

对于 $\text{getMin}$ 方法，返回 $\text{minStack}$ 的栈顶元素。

根据上述操作，$\text{minStack}$ 的元素个数总是少于或等于 $\text{stack}$ 的元素个数，且 $\text{minStack}$ 是单调栈，栈底到栈顶的元素非严格单调递减。

由于当每次入栈的元素是最小元素时，该元素都会入栈 $\text{minStack}$，且 $\text{minStack}$ 具有单调性，因此在只有 $\text{push}$ 操作的情况下，$\text{minStack}$ 的栈顶元素一定是最小元素，$\text{getMin}$ 方法返回的一定是最小元素。

在有 $\text{pop}$ 操作的情况下，$\text{minStack}$ 的栈顶元素也一定是最小元素，理由如下。

根据 $\text{push}$ 和 $\text{pop}$ 方法的实现可知，$\text{minStack}$ 中的每个元素都在 $\text{stack}$ 中有一个对应元素，对应元素的含义是，这两个元素（分别属于两个栈）同时入栈和同时出栈。当一个元素从 $\text{minStack}$ 出栈时，该元素在 $\text{stack}$ 中的对应元素同时出栈，此时两个栈内的元素仍然符合最小栈的性质。

下图为题中示例的三次入栈操作的过程。

下图为题中示例的一次出栈操作的过程。由于 $\text{stack}$ 的出栈元素 $-3$ 和 $\text{minStack}$ 的栈顶元素相等，因此也将 $\text{minStack}$ 的栈顶元素出栈。

代码

class MinStack {
    Deque<Integer> stack;
    Deque<Integer> minStack;

    public MinStack() {
        stack = new ArrayDeque<Integer>();
        minStack = new ArrayDeque<Integer>();
    }
    
    public void push(int val) {
        stack.push(val);
        if (minStack.isEmpty() || val <= minStack.peek()) {
            minStack.push(val);
        }
    }
    
    public void pop() {
        int val = stack.pop();
        if (minStack.peek() == val) {
            minStack.pop();
        }
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

复杂度分析

• 时间复杂度：构造方法和每一项操作的时间复杂度都是 $O(1)$。

• 空间复杂度：$O(n)$，其中 $n$ 是元素个数。空间复杂度主要取决于栈空间，常规栈和最小元素栈的空间都是 $O(n)$。