155. Min Stack [easy] (Python)_minstack python-CSDN博客

本文链接：https://blog.csdn.net/coder_orz/article/details/52047023

题目链接

https://leetcode.com/problems/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），使支持在常数时间内完成push，pop，top，获取最小元素getMin。

push(x) – 将x入栈.
pop() – 移除栈顶元素.
top() – 获取栈顶元素.
getMin() – 获取栈里最小元素.

思路方法

此题的关键有两点：一是在常数时间内完成四种操作；二是要注意，压栈和出栈操作都可能更新栈里最小元素，尤其是出栈操作。在实现getMin函数时，为了避免超过常数时间的查询或搜索，所以需要以某种方式记录栈里最小值的历史信息。

思路一

定义栈里每个元素为一个元组(x, cur_min)，表示当前元素和截至当前元素时的最小值。不管栈怎么变化，总可以常数时间执行四种操作。

代码

class MinStack(object):

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

    def push(self, x):
        """
        :type x: int
        :rtype: void
        """
        pre_min = 2147483647 if len(self.stack) == 0 else self.stack[-1][1]
        cur_min = min(x, pre_min)
        self.stack.append((x, cur_min))

    def pop(self):
        """
        :rtype: void
        """
        self.stack.pop()

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

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


# 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()

说明
本思路也可以用两个栈来实现，一个栈存放正常的元素，一个栈存放当前最小值，两个栈同步操作即可。

思路二

有点类似思路一，但是并不改变栈元素的结构，而是将当前最小值一同入栈，为节省空间，仅在当前最小值更改时才入栈新的最小值。所以该栈的push和pop实际上可能是两次push或pop，具体可参考代码。

代码

class MinStack(object):

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.min = 2147483647
        self.stack = []

    def push(self, x):
        """
        :type x: int
        :rtype: void
        """
        if x <= self.min:
            self.stack.append(self.min)
            self.min = x
        self.stack.append(x)

    def pop(self):
        """
        :rtype: void
        """
        peak = self.stack.pop()
        if peak == self.min:
            self.min = self.stack.pop()

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

    def getMin(self):
        """
        :rtype: int
        """
        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()

思路三

这个思路稍微难理解一点，其思想是在栈中记录最小值与当前值的差，同时用一个成员变量记录当前的最小值。假设该栈已经建立，那么当栈顶元素为正时，其表示的是真正的当前元素比当前最小元素大多少；当栈顶元素为负时，其表示的是前一个最小元素比当前元素大多少，且真正的当前元素就是当前最小元素。

代码

class MinStack(object):

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.min = 2147483648
        self.stack = []

    def push(self, x):
        """
        :type x: int
        :rtype: void
        """
        if not self.stack:
            self.min = x
        self.stack.append(x - self.min)
        if x < self.min:
            self.min = x

    def pop(self):
        """
        :rtype: void
        """
        peak = self.stack.pop()
        if peak < 0:
            self.min = self.min - peak

    def top(self):
        """
        :rtype: int
        """
        if self.stack[-1] < 0:
            return self.min
        else:
            return self.min + self.stack[-1]

    def getMin(self):
        """
        :rtype: int
        """
        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()