LeetCode - 解题笔记 - 155 - Min Stack

Solution 1

【参考官方题解】这道题一开始我甚至觉得要自己实现一个栈……然而看了题解之后才发现是不用的。

【难点】需要根据栈内元素的变化动态地维护最小值。

【朴素解法】额外使用一个栈，保存每一次插入数据的最小值结果

【优化解法】【参考】这样才是面试的时候才会被问到的问题吧……使用差值进行维护，争产情况应出现正差值，根据min和差值恢复当前数据；如果出现负差值，即出现了新的最小值，根据min和差值恢复原来的min，当前数据即现在的min

【注意】额外的问题，计算插值可能出现INT_MIN-INT_MAX的情形，所以需要扩增数据结构

• 时间复杂度：$O(H)$，其中$H$为输入操作序列的原子操作个数，每一个操作保证常数时间复杂度
• 空间复杂度：$O(N)$，其中$N$为输入操作序列中，push的个数，最坏情况下所有push的元素都需要保存

class MinStack {
public:
    MinStack() {
        s = stack<long int>();
        minV = INT_MAX;
    }
    
    void push(int val) {
        if (this->s.empty()) {
            this->s.push(0);
            this->minV = val;
        } else {
            long int delta = val - this->minV;
            this->s.push(delta);
            this->minV = delta > 0? this-> minV: val;
        }
    }
    
    void pop() {
        if (!this->s.empty()) {
            long int delta = s.top();
            s.pop();
            if (delta < 0) {
                // 当前弹出元素为期之后加入元素的最小值
                this->minV = this->minV - delta;
            }
        }
    }
    
    int top() {
        int top = -1;
        if (!this->s.empty()) {
            long int delta = s.top();
            // s.pop();
            if (delta < 0) {
                // 当前弹出元素为期之后加入元素的最小值
                top = this->minV;
                // this->minV = this->minV - delta;
            } else {
                // 否则，恢复原始数据
                top = this->minV + delta;
            }
        }
        
        return top;
    }
    
    int getMin() {
        if (!this->s.empty()) {
            return this->minV;
        }
        
        return -1;
    }
    
private:
    stack<long int> s;
    long int minV;
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

Solution 2

Solution 1的Python实现

class MinStack:

    def __init__(self):
        self.stack = list()
        self.minV = None

    def push(self, val: int) -> None:
        if not self.stack:
            self.stack.append(0)
            self.minV = val
        else:
            delta = val - self.minV
            self.stack.append(delta)
            self.minV = self.minV if delta > 0 else val
            
        # print("PUSH", self.stack, self.minV)

    def pop(self) -> None:
        if self.stack:
            delta = self.stack.pop()
            if delta < 0:
                self.minV -= delta
                
        # print("POP", self.stack, self.minV)
        

    def top(self) -> int:
        top = None
        if self.stack:
            delta = self.stack[-1]
            if delta < 0:
                top = self.minV
            else:
                top = self.minV + delta
                
        # print("TOP", self.stack, self.minV)
        return top
            

    def getMin(self) -> int:
        if self.stack:
            return self.minV
        
        # print("GETMIN", self.stack, self.minV)
        return -1

# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(val)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()