[LeetCode] 155. Min Stack

Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.

• push(x) -- Push element x onto stack.
• pop() -- Removes the element on top of the stack.
• top() -- Get the top element.
• getMin() -- Retrieve the minimum element in the stack.

例子，

Example:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> Returns -3.
minStack.pop();
minStack.top();      --> Returns 0.
minStack.getMin();   --> Returns -2.

这个题我给出两种解法，一种用了两个stack，一种只需要用一个stack。两种做法的复杂度都是

时间O(1)

空间O(n)

1. 两个stack。创建两个stack，一个叫stack，另一个叫做minstack。

push() - 每当需要push的时候，元素会被正常push到stack，同时需要看一下当前元素与min的关系，以决定是否需要把这个元素push到minStack。minStack只push当前遍历到的最小值。

pop() - stack会正常pop出当前元素；因为minStack的顶端存的永远是当前的最小值，所以当stack弹出一个元素的时候，需要去minStack看一下这个元素是不是最小值，如是，也需要从minStack弹出，这样minStack顶端保留的永远是最小值。

top() - 同peek，只是看一下stack顶端的元素

getMin() - 去peek minStack顶端的元素，因为minStack的顶端永远是当前遍历到的最小值

JavaScript实现

/**
 * initialize your data structure here.
 */
var MinStack = function () {
    this.stack = [];
    this.minStack = [];
};

/** 
 * @param {number} x
 * @return {void}
 */
MinStack.prototype.push = function (x) {
    this.stack.push(x);
    if (this.minStack.length) {
        let top = this.minStack[this.minStack.length - 1];
        if (x <= top) {
            this.minStack.push(x);
        }
    } else {
        this.minStack.push(x);
    }
};

/**
 * @return {void}
 */
MinStack.prototype.pop = function () {
    let pop = this.stack.pop();
    let top = this.minStack[this.minStack.length - 1];
    if (pop === top) {
        this.minStack.pop();
    }
};

/**
 * @return {number}
 */
MinStack.prototype.top = function () {
    return this.stack[this.stack.length - 1];
};

/**
 * @return {number}
 */
MinStack.prototype.getMin = function () {
    return this.minStack[this.minStack.length - 1];
};

/**
 * Your MinStack object will be instantiated and called as such:
 * var obj = new MinStack()
 * obj.push(x)
 * obj.pop()
 * var param_3 = obj.top()
 * var param_4 = obj.getMin()
 */

Java实现

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

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

2. 一个stack，同时创建一个变量记录最小值min。

push() - push的时候看一下当前元素是否比min小，若是则把上一个min放进stack，同时更新当前最小值min。

pop() - 如果弹出值 == 当前最小值，那么再弹一次的值为上一个最小值也即出栈后更新的最小值

top() - 同peek，只是看一下stack顶端的元素

getMin() - 输出min即可

JavaScript实现

/**
 * initialize your data structure here.
 */
var MinStack = function () {
    this.stack = [];
    this.min = Number.MAX_SAFE_INTEGER;
};

/** 
 * @param {number} x
 * @return {void}
 */
MinStack.prototype.push = function (x) {
    // 当前值比min值更小
    if (this.min >= x) {
        // 将上一个min最小值保存入栈
        this.stack.push(this.min);
        // 更新当前最小值
        this.min = x;
    }
    this.stack.push(x)
};

/**
 * @return {void}
 */
MinStack.prototype.pop = function () {
    // 如果弹出值 == 当前最小值，那么再弹一次的值为上一个最小值也即出栈后更新的最小值
    if (this.stack.pop() == this.min) {
        this.min = this.stack.pop();
    }
};

/**
 * @return {number}
 */
MinStack.prototype.top = function () {
    return this.stack[this.stack.length - 1];
};

/**
 * @return {number}
 */
MinStack.prototype.getMin = function () {
    return this.min;
};

/**
 * Your MinStack object will be instantiated and called as such:
 * var obj = new MinStack()
 * obj.push(x)
 * obj.pop()
 * var param_3 = obj.top()
 * var param_4 = obj.getMin()
 */

Java实现

class MinStack {
    int min = Integer.MAX_VALUE;
    Stack<Integer> stack = new Stack<>();

    /** initialize your data structure here. */
    public MinStack() {

    }

    public void push(int x) {
        if (x <= min) {
            stack.push(min);
            min = x;
        }
        stack.push(x);
    }

    public void pop() {
        if (stack.pop() == min) {
            min = stack.pop();
        }
    }

    public int top() {
        return stack.peek();
    }

    public int getMin() {
        return min;
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

LeetCode 题目总结