算法 中等 | 12. 带最小值操作的栈

题目描述

实现一个栈, 支持以下操作:

1. push(val) 将 val 压入栈
2. pop() 将栈顶元素弹出, 并返回这个弹出的元素
3. min() 返回栈中元素的最小值
4. 要求 O(1) 开销.

样例

输入: 
  push(1)
  min()
  push(2)
  min()
  push(3)
  min()
输出: 
  1
  1
  1
注意事项
保证栈中没有数字时不会调用 min()

解题思路

使用两个仅支持 pop 和 push 的栈就可以完成, stack 储存压入的数据, minStack 储存最小值.

1. push 直接把元素压入 stack, 对于 minStack, 如果它为空则直接压入, 反之压入当前元素与 minStack 栈顶的最小值
2. pop 两个栈都弹出一个元素, 返回 stack 弹出的元素
3. min 返回 minStack 的栈顶

还可以令 minStack 为单调栈, 即push时只有元素更小的时候才放入这个栈, 而pop时只有栈顶与stack栈顶相同时才弹出

这样可以节约一定的空间, 但是实质上空间复杂度仍然是 O(n), 且多了一些判断, 并不一定更优

java题解

题解1

public class MinStack {
    private Stack<Integer> stack;
    private Stack<Integer> minStack;
    
    public MinStack() {
        stack = new Stack<Integer>();
        minStack = new Stack<Integer>();
    }

    public void push(int number) {
        stack.push(number);
        if (minStack.isEmpty()) {
            minStack.push(number);
        } else {
            minStack.push(Math.min(number, minStack.peek()));
        }
    }

    public int pop() {
        minStack.pop();
        return stack.pop();
    }

    public int min() {
        return minStack.peek();
    }
}

题解2

单调栈版本，节省更多空间。
但是空间复杂性并没有改变。

public class MinStack {
    private Stack<Integer> stack;
    private Stack<Integer> minStack;

    public MinStack() {
        stack = new Stack<Integer>();
        minStack = new Stack<Integer>();
    }

    public void push(int number) {
        stack.push(number);
        if (minStack.empty() == true)
            minStack.push(number);
        else if (minStack.peek() >= number) // 这里考虑的相等的情况也会继续push
            minStack.push(number);
    }

    public int pop() {
        if (stack.peek().equals(minStack.peek()))
            minStack.pop();
        return stack.pop();
    }

    public int min() {
        return minStack.peek();
    }
}

C++题解

题解1

class MinStack
{
  public:
    stack<int> stk, minstk;

    void push(int number)
    {
        stk.push(number);
        if (minstk.empty() or number <= minstk.top())
        {
            minstk.push(number);
        }
    }

    int pop()
    {
        int top = stk.top();
        stk.pop();
        if (top == minstk.top())
        {
            minstk.pop();
        }
        return top;
    }

    int min()
    {
        return minstk.top();
    }
};

题解2

单调栈版本，节省更多空间。
但是空间复杂性并没有改变。

class MinStack
{
  private:
    stack<int> stk, minStk;

  public:
    MinStack()
    {
        // do intialization if necessary
    }

    /*
     * @param number: An integer
     * @return: nothing
     */
    void push(int number)
    {
        stk.push(number);
        if (minStk.empty() || number <= minStk.top())
        {
            minStk.push(number);
        }
    }

    /*
     * @return: An integer
     */
    int pop()
    {
        if (stk.top() == minStk.top())
        {
            minStk.pop();
        }
        int ret = stk.top();
        stk.pop();
        return ret;
    }

    /*
     * @return: An integer
     */
    int min()
    {
        return minStk.top();
    }
};

python题解

题解1

class MinStack:
    
    def __init__(self):
        self.stack = []
        self.minStack = []

    """
    @param: number: An integer
    @return: nothing
    """
    def push(self, number):
        self.stack.append(number)
        if len(self.minStack) == 0:
            self.minStack.append(number)
        else:
            self.minStack.append(min(number, self.minStack[-1]))

    """
    @return: An integer
    """
    def pop(self):
        ret = self.stack[-1]
        del(self.stack[-1], self.minStack[-1])
        return ret

    """
    @return: An integer
    """
    def min(self):
        return self.minStack[-1]

题解2

单调栈版本，节省更多空间。
但是空间复杂性并没有改变。

class MinStack:
    
    def __init__(self):
        self.stack = []
        self.minStack = []

    """
    @param: number: An integer
    @return: nothing
    """
    def push(self, number):
        self.stack.append(number)
        if len(self.minStack) == 0:
            self.minStack.append(number)
        else:
            self.minStack.append(min(number, self.minStack[-1]))

    """
    @return: An integer
    """
    def pop(self):
        ret = self.stack[-1]
        del(self.stack[-1], self.minStack[-1])
        return ret

    """
    @return: An integer
    """
    def min(self):
        return self.minStack[-1]