Leetcode 155. Min Stack

easy 难度的题目, 运用一个辅助栈来存储当前最小的元素, 思路简单 :

class MinStack {
    private Stack<Integer> dataStack;
    private Stack<Integer> minStack;
    int minValue;
    /** initialize your data structure here. */
    public MinStack() {
        dataStack = new Stack<>();
        minStack = new Stack<>();
        minValue = Integer.MAX_VALUE;
    }
    
    public void push(int x) {
        dataStack.add(x);
        minValue = Math.min(minValue,x);
        minStack.add(minValue);
    }
    
    public void pop() {
        dataStack.pop();
        minStack.pop();
        // 这里少了一行, 是不能少的
        minValue = !minStack.isEmpty() ? minStack.peek() : Integer.MAX_VALUE;
    }
    
    public int top() {
        return dataStack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

这里容易错误的就是在我注释的地方, 如果这里没有这一行, 那么当保存最小值的栈中元素全部出栈后, 最小值不是最初的 Integer.MAX_VALUE, 而是栈空前的最后一个元素, 所以当栈空的时候也需要对栈进行初始化.

上面的代码是可以进一步地简化, 主要的操作在于入栈和出栈操作, 而在入栈操作中, 当入栈元素大于辅助栈中的栈顶元素时, 辅助栈重复入栈栈顶元素. 所以这里可以简化, 当入栈元素, 小于或者等于辅助栈的栈顶元素时, 辅助栈才进行入栈元素; 当出栈元素等于辅助栈的出栈元素时, 辅助栈才出栈 :

class MinStack {
    private Stack<Integer> dataStack = new Stack<>();
    private Stack<Integer> minStack = new Stack<>();
    private int min;
    
    /** initialize your data structure here. */
    public MinStack() {
        dataStack = new Stack<>();
        minStack = new Stack<>();
        min = Integer.MAX_VALUE;
    }
    
    public void push(int x) {
        dataStack.push(x);
        if (x <= min) {
            min = x;
            minStack.push(x);
        }
    }
    
    public void pop() {
        if (dataStack.peek().equals(minStack.peek())) {
            dataStack.pop();
            minStack.pop();
        } else {
            dataStack.pop();
        }
        min = minStack.isEmpty() ? Integer.MAX_VALUE : minStack.peek();
    }
    
    public int top() {
        return dataStack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

在 pop() 操作对数据栈和辅助栈栈顶元素进行比较时, 最开始我使用的是 == , 这里是错误的, 因为在声明栈的时候, Stack<Integer> 这里声明的是 Integer 对象, 所以进行相关操作得到的都是对象, 对象的比较应该使用 equals() 来进行比较. 

看到还有一种不需要辅助栈, 只需要一个保存最小值的变量的做法, 但是在进栈和出栈的时候, 需要对最小值进行判断, 和相关的操作 :

class MinStack {
    private Stack<Integer> stack;
    private int min;
    /** initialize your data structure here. */
    public MinStack() {
        stack = new Stack<>();
        min = Integer.MAX_VALUE;
    }
    
    public void push(int x) {
        if (x <= min) {
            stack.push(min);
            min = x;
        }
        stack.push(x);
    }
    
    public void pop() {
        if (stack.peek() == min) {
            stack.pop();
            min = stack.pop();
        } else {
            stack.pop();
        }
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        return min;
    }
}

这种做法的时间复杂度是最低的.