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.

思路

初始思路很偷懒，别的操作都好说，getmin的时候for循环查最短的元素。当然，会超时。看了下超时的用例，主要是一直在调用getmin，所以我将min的查询放到了push和pop中，getmin的时候直接return min。

代码

class MinStack(object):    stack = []    Min = False    Minindex = False    def __init__(self):        """        initialize your data structure here.        """        self.stack = []        self.Min = False        self.Minindex = False    def push(self, x):        """        :type x: int        :rtype: void        """        self.stack += [x]        if type(self.Min) == type(False) or self.Min > x:            self.Min = x            self.Minindex = len(self.stack) - 1    def pop(self):        """        :rtype: void        """        if self.stack:            self.stack = self.stack[:-1]            if not self.stack:                self.Min = False                self.Minindex = False            elif type(self.Minindex) != type(False) and self.Minindex == len(self.stack):                Min = self.stack[0]                minIndex = 0                for index, i in enumerate(self.stack):                    if Min > i:                        Min = i                        minIndex = index                self.Min = Min                self.Minindex = minIndex    def top(self):        """        :rtype: int        """        if self.stack:            return self.stack[-1]    def getMin(self):        """        :rtype: int        """        if self.stack:            return self.Min# Your MinStack object will be instantiated and called as such:# obj = MinStack()# obj.push(x)# obj.pop()# param_3 = obj.top()# param_4 = obj.getMin()

过是过了，但是最佳算法肯定不是这么搞的呀！遂看了下discussion，发现以下几个有趣的算法。

代码一（作者reeclapple）

public class MinStack {    long min;    Stack<Long> stack;    public MinStack(){        stack=new Stack<>();    }    public void push(int x) {        if (stack.isEmpty()){            stack.push(0L);            min=x;        }else{            stack.push(x-min);//Could be negative if min value needs to change            if (x<min) min=x;        }    }    public void pop() {        if (stack.isEmpty()) return;        long pop=stack.pop();        if (pop<0)  min=min-pop;//If negative, increase the min value    }    public int top() {        long top=stack.peek();        if (top>0){            return (int)(top+min);        }else{           return (int)(min);        }    }    public int getMin() {        return (int)min;    }}

这个算法的好处在于push的时候存x - min，如果结果小于0就更新min，pop的时候如果pop值小于0就更新min值，就可以恢复到除去pop值的min值。最后getmin的时候直接输出min值即可，不用遍历list

代码二（作者leftpeter2）

class MinStack{    static class Element    {        final int value;        final int min;        Element(final int value, final int min)        {            this.value = value;            this.min = min;        }    }    final Stack<Element> stack = new Stack<>();    public void push(int x) {        final int min = (stack.empty()) ? x : Math.min(stack.peek().min, x);        stack.push(new Element(x, min));    }    public void pop()    {        stack.pop();    }    public int top()    {        return stack.peek().value;    }    public int getMin()    {        return stack.peek().min;    }}

这个算法更精巧，完全不用计算。只需更改下存入的数据结构。如代码所示，该数据结构中带有min值，存入x的时候同时会将当前的min值存入。这样的好处是无论何时，栈顶元素的min值肯定是当前栈的min值，而当元素pop出去后也不用重新计算新的min值，因为除去pop的那个元素后当前的min值还在栈顶的min中。

代码三（作者sometimescrazy）

class MinStack {    int min = Integer.MAX_VALUE;    Stack<Integer> stack = new Stack<Integer>();    public void push(int x) {        // only push the old minimum value when the current         // minimum value changes after pushing the new value x        if(x <= min){                      stack.push(min);            min=x;        }        stack.push(x);    }    public void pop() {        // if pop operation could result in the changing of the current minimum value,         // pop twice and change the current minimum value to the last minimum value.        if(stack.pop() == min) min=stack.pop();    }    public int top() {        return stack.peek();    }    public int getMin() {        return min;    }}

这个答案也很不错，存x的时候如果要更新min值，就将min值也存入stack中，pop的时候如果pop值等于min，则min等于stack再次pop出来的值。总的来说就是min值更新的时候将之前的min值也存入stack中，pop的是min值时则恢复之前的min值。缺点就是最坏情况的时候空间占用会比较多。

总结

学到了3种有意思的算法，收获不少，以后也要每做一题都看看discussion学习学习。