155. Min Stack

最新推荐文章于 2020-08-03 10:03:11 发布

转载最新推荐文章于 2020-08-03 10:03:11 发布 · 49 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/yuchenkit/p/7169507.html

本文介绍了一种支持常数时间内进行push、pop、top操作及获取最小元素的栈实现方法。通过在栈中存储当前元素与最小值的差值来达到目的，并提供两种实现方案。

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.

存一个instance variable表示到目前为止的最小值

stack里存的是：

如果当前值大于之前的最小值，存当前值－最小值(正数)

如果当前值小于之前的最小值，则这个值变成新的最小值，存当前值－最小值（负数）并更新最小值

pop: pop出栈顶元素cur, 如果cur < 0,说明当前ｐｏｐ出的值是当前最小值，出栈后把最小值更新为min - cur; 如果ｃｕｒ > 0, 说明当前值大于当前最小值，应该是cur + pop

top: 栈顶元素cur = stack.peek(), 如果cur < 0, 说明当前值是最小值，返回min，如果cur> 0, 说明当前值大于最小值，实际为cur + min

public class MinStack {
    Stack<Long> stack;
    int min;
    /** initialize your data structure here. */
    public MinStack() {
        stack = new Stack<Long>();
        min = 0;
    }
    
    public void push(int x) {
        if (stack.isEmpty()) {
            min = x;
            stack.push(0L);
            return;
        }
        stack.push((long)x - min);
        if (x < min) {
            min = x;
        }
    }
    
    public void pop() {
        long cur = stack.pop();
        if (cur < 0) {
            min = (int)(min - cur);
        }
    }
    
    public int top() {
        if (stack.peek() < 0L) {
            return min;
        } else {
            return (int)(min + 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();
 */

另一种办法

分析：保存到目前为止的最小值。当出栈导致更新最小值时，如果记录了之前的最小值信息，就能更新到ｐｏｐ出当前元素后的最小值。

public class MinStack {
    Stack<Integer> stack;
    int min;
    /** initialize your data structure here. */
    public MinStack() {
        stack = new Stack<Integer>();
        min = Integer.MAX_VALUE;
    }
    
    public void push(int x) {
        if (x <= min) {　//这里要用<=。如果x == min，ｘ也会被判断为新的最小值，在ｐｏｐ时连ｐｏｐ两次，因此此时也要ｐｕｓｈ两次
            stack.push(min);
            min = x;
        }
        stack.push(x);
    }
    
    public void pop() {
        int cur = stack.pop();
        if (cur == 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();
 */

转载于:https://www.cnblogs.com/yuchenkit/p/7169507.html