[leetcode] min stack问题

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.
实现一个能够返回最小值的栈

leetcode 提交地址

采用额外栈

比较容易想到的是利用一个额外值记录最小值的变化

class MinStack(object):
    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []
        self.min_stack = []

    def push(self, x):
        """
        :type x: int
        :rtype: void
        """
        if len(self.stack) == 0:
            self.stack.append(x)
            self.min_stack.append(x)
        else:
            self.stack.append(x)
            # 需要注意此处当等于最小值的时候，也需要压入
            if self.min_stack[len(self.min_stack)-1] >= x:
                self.min_stack.append(x)



    def pop(self):
        """
        :rtype: void
        """
        value = self.stack.pop()
        min_value = self.min_stack[len(self.min_stack) -1]
        if value == min_value:
            self.min_stack.pop()
        return value

    def top(self):
        """
        :rtype: int
        """
        return self.stack[len(self.stack)-1]

    def getMin(self):
        """
        :rtype: int
        """
        return self.min_stack[len(self.min_stack) -1]

不采用额外栈

• 方法一: 当前值比最小值小的时候，需要在更新最小值之前备份一下上一个最小值，由此再该最小值出栈之后，仍能找到上一个最小值。

class MinStack(object):
    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []
        self.min_num = 0xffffffff

    def push(self, x):
        """
        :type x: int
        :rtype: void
        """
        if x <= self.min_num:
            self.stack.append(self.min_num)  # 相当于备份一下上一个最小值
            self.min_num = x
        self.stack.append(x)

    def pop(self):
        """
        :rtype: void
        """
        if self.stack.pop() == self.min_num:
            self.min_num = self.stack.pop()  #当前最小值已经出栈，返回到前一个最小值，即备份的值

    def top(self):
        """
        :rtype: int
        """
        return self.stack[len(self.stack)-1]

    def getMin(self):
        """
        :rtype: int
        """
        return self.min_num

方法二 利用当前值和最小的值的关系，栈内保存的是当前值和最小值的差，这样当最小值出栈时，能够通过关系找到上一个最小值。这个方法比上一个方法慢，因为需要计算。

class MinStack(object):
    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []
        self.min_num = 0xffffffff

    def push(self, x):
        """
        :type x: int
        :rtype: void
        """
        if len(self.stack) == 0:
            self.stack.append(0)
            self.min_num = x

        else:
            self.stack.append(x - self.min_num)
            if x < self.min_num:
                self.min_num = x

    def pop(self):
        """
        :rtype: void
        """
        if len(self.stack) == 0:
            return
        value = self.stack.pop()
        if value < 0:
            self.min_num = self.min_num - value


    def top(self):
        """
        :rtype: int
        """
        value = self.stack[len(self.stack)-1]
        if value > 0:
            return self.min_num + value
        else:
            return self.min_num


    def getMin(self):
        """
        :rtype: int
        """
        return self.min_num