LeetCode-155-最小栈

---

题目描述：

设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。

• push(x) – 将元素 x 推入栈中。
• pop() – 删除栈顶的元素。
• top() – 获取栈顶元素。
• getMin() – 检索栈中的最小元素。

---

示例：

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

---

解题思路：
Alice: 怎么会有这种题目呢 ？ 各种语言都有实现好的栈这种数据结构，我们在加个最小值的属性，组成一个类，然后再包一层逻辑处理一下不就行了吗 ？
Bob: 对呀，这种题目可能是要考察程序的鲁棒性还有代码风格 ？可以实现的方式太多了。
Alice: 我知道用Python的列表就可以实现，还是比较方便的，list 对象有 append 和pop方法刚好可以拿来用。
Bob: 对，然后入栈的时候要可以用 “打擂台” 的方式维护一个最小值。
Alice: 还有出栈的时候也要维护最小值，这样查询的时候直接返回现有的最小值就好了，这样查询时间就是常数的了。
Bob: 不错不错，就是出栈的时候维护最小值应该还可以“精进”一下。
Alice: 我们看看别人的实现办法吧。
Bob: 😎😎

---------------------------------------------------------------Alice&Bob---------------------------------------------------------------

Alice：我看到了有人用两个栈来做的，一个栈放数据，一个栈维护最小值。
Bob: 一个栈维护最小值 ？
Alice: 把两个栈分别叫做数据栈和辅助栈吧，第二个栈里面存的是第一个栈中每个元素对应的最小值，两个栈的长度是始终相等的。第二个栈的栈顶始终对应着第一个栈中的最小值，任何时刻都是的。
Bob: 不错不错，空间换时间，这样出栈入栈也很快。就是栈中的数据一多，用两倍的空间岂不是不太好。
Alice: 刚才说的那种辅助栈和数据栈长度始终相同的是同步的，还有不同步的，辅助栈用的空间就少多了。这种不同步的办法是辅助栈中的记录只和数据栈中的最小值对应，就是把原来不是最小值的那部分记录合并到最小值对应的那部分记录。这样说起来不是很直观。
Bob: 我大概明白了，我们举个例子吧。像这一组操作，如果是同步的两个栈，三个push之后应该是[0,1,0], [0,0,0]。如果是非同步的两个栈，三个push之后应该是[0,1,0], [0, 0],就是把 1 对应的最小值合并到第一个 0 那里去嘛 ？

["MinStack","push","push","push","getMin","pop","getMin"]
[[],[0],[1],[0],[],[],[]]

Alice: 是呀，一点就通啊。😉

---

代码：
Python 方法一： 使用列表实现 “最小栈”

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.data = []
        self.minValue = 0
        # 初始化，准备一个空列表和存储最小值的变量。


    def push(self, x: int) -> None:

        self.data.append(x)
        # 入栈
        if len(self.data) == 1:
            # 如果是入栈的第一个元素，最小值就是 x 本身
            self.minValue = x
            # 注意这里直接 return 
            return 
        # 如果最小栈中已经有最小值了，就将入栈的元素与已有的最小值比较
        if x < self.minValue:
            self.minValue = x
            return 

    def pop(self) -> None:
        # 出栈操作也要维护 最小值    
        if len(self.data) > 1:
            self.minValue = min(self.data[:-1])
        else:
            self.minValue = 'not exist'
        return self.data.pop()

    def top(self) -> int:
        # 返回列表末尾元素，即栈顶元素
        return self.data[-1]

    def getMin(self) -> int:
        # 返回最小值，这里getMin方法的时间是常数的，因为维护最小值的过程被分散在入栈和出栈的操作中了。
        return self.minValue

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

Python 解法二: 数据栈 + 辅助栈 + 非同步操作。注意这里需要记录每个元素入栈之后对应的最小值。

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.data = []
        # 记录每个元素
        self.minValues = []
        # 记录每个元素入栈之后栈中的最小值


    def push(self, x: int) -> None:
        self.data.append(x)
        # 入栈
        if len(self.minValues) == 0:
            # 栈底元素入栈时的最小值就是其自身
            self.minValues.append(x)
        else:
            if self.minValues[-1] >= x:
                # 注意这是 >= ，这意味着如果有两个相同的元素入栈，在minValues 可能会记录两个相同的最小值，这是为了在出栈是便于维护出栈操作后的最小值。
                self.minValues.append(x)
        return

    def pop(self) -> None:
        if len(self.minValues) and len(self.data) and self.data[-1] == self.minValues[-1]:
            self.minValues.pop()
            # 看这里，当数据栈中出栈的元素等于当前栈中的最小值的时候，要将minValues中的最小值也出栈。只有在minValues重复记录最小值，才能维护在minVlues[-1] 始终是当前数据栈中的最小值。

        if len(self.data):
            return self.data.pop()

    def top(self) -> int:
        return self.data[-1]

    def getMin(self) -> int:
        return self.minValues[-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()

Python 方法三： 数据栈 + 辅助栈 + 同步操作。注意这里，辅助栈里存储了数据栈中的每个元素对应的最小值，也就是说 len(self.minValues) == len(self.data) 始终成立。

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.data = []
        # 数据栈
        self.minValues = []
        # 辅助栈，记录数据栈中每个元素对应的最小值。


    def push(self, x: int) -> None:
        # 数据栈入栈操作
        self.data.append(x)
        # 辅助栈入栈操作
        if len(self.minValues) == 0:
            self.minValues.append(x)
            # 辅助栈中的栈底元素就是数据栈中的栈底元素
        else:
            if self.minValues[-1] > x:
                # 数据栈中新入栈的元素是新的最小值，辅助栈加入新的元素
                self.minValues.append(x)
            else:
                # 否则，辅助栈就重复上一个最小值
                self.minValues.append(self.minValues[-1])


    def pop(self) -> None:
        if len(self.data):
            self.minValues.pop()
            return self.data.pop()


    def top(self) -> int:
        if len(self.data):
            return self.data[-1]


    def getMin(self) -> int:
        if len(self.minValues):
            return self.minValues[-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()

Java 方法三： 数据栈 + 辅助栈 + 同步操作。

class MinStack {

    /** initialize your data structure here. */
    private Stack<Integer> data;
    private Stack<Integer> minValues;

    public MinStack() {
        data = new Stack();
        minValues = new Stack();
    }
    
    public void push(int x) {
        data.push(x);
        if(minValues.empty() == true){
            minValues.push(x);
        }else{
            if(minValues.peek() > x){
                minValues.push(x);
            }else{
                minValues.push(minValues.peek());
            }
        }
        return;
    }
    
    public void pop() {
        if(data.empty() == false){
            minValues.pop();
            data.pop();
        }
        return;
    }
    
    public int top() {
        return data.peek();
    }
    
    public int getMin() {
        return minValues.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();
 */

---

易错点：

• 一些测试样例：

["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]
["MinStack","push","push","push","getMin","pop","getMin"]
[[],[0],[1],[0],[],[],[]]

• 答案：

[null,null,null,null,-3,null,0,-2]
[null,null,null,null,0,null,0]

• 在 pop, top, getMin，中存在着数组越界访问的风险，虽然题目中并没有提及，最好还是在访问前加上 len(self.data) 的判断条件。

---

总结：

• Java 中的栈
• 参考题解

---