【006】LeetCode155 最小栈

题目155. 最小栈

6.1 官方解析

点击这里

方法一：辅助栈

算法

按照上面的思路，我们只需要设计一个数据结构，使得每个元素 a 与其相应的最小值 m 时刻保持一一对应。因此我们可以使用一个辅助栈，与元素栈同步插入与删除，用于存储与每个元素对应的最小值。

当一个元素要入栈时，我们取当前辅助栈的栈顶存储的最小值，与当前元素比较得出最小值，将这个最小值插入辅助栈中；

当一个元素要出栈时，我们把辅助栈的栈顶元素也一并弹出；

在任意一个时刻，栈内元素的最小值就存储在辅助栈的栈顶元素中。

class MinStack {
    stack<int> x_stack;
    stack<int> min_stack;
public:
    MinStack() {
        min_stack.push(INT_MAX);
    }
    
    void push(int x) {
        x_stack.push(x);
        min_stack.push(min(min_stack.top(), x));
    }
    
    void pop() {
        x_stack.pop();
        min_stack.pop();
    }
    
    int top() {
        return x_stack.top();
    }
    
    int getMin() {
        return min_stack.top();
    }
};

复杂度分析

时间复杂度：对于题目中的所有操作，时间复杂度均为 O(1)。因为栈的插入、删除与读取操作都是 O(1)，我们定义的每个操作最多调用栈操作两次。

空间复杂度：O(n)，其中 n 为总操作数。最坏情况下，我们会连续插入 n 个元素，此时两个栈占用的空间为 O(n)。

6.2 解法1

（这道题竟然是借助语言中成熟的库，我还以为要自己动手使用基本的数组 或者 链表 去实现呢）

概括一下官方解析：我们每次插入原栈时，都向新栈插入一次原栈里所有值的最小值(新栈栈顶和待插入值中更小的那一个)；每次从原栈里取出数字时，同时取出新栈的栈顶。

这样的好处是可以避免判断，但是每次都要插入取出，时间复杂度略高。

下面这个解法是leetcode 101 中的：

我们可以额外建立一个新栈，栈顶表示原栈里所有值的最小值。

每当在原栈里插入一个数字时，若该数字小于等于新栈栈顶，则表示这个数字是原栈中的最小值，我们将其同时插入新栈内。

每当从原栈里取出一个数字时，若该数字等于新栈栈顶，则表示这个数字就是原栈中最小值之一，我们将同时取出新栈栈顶的值。

class MinStack {
private:
    stack<int> s, min_s;
public:
    /** initialize your data structure here. */
    MinStack() { }
    
    void push(int val) {
        s.push(val);
        if (min_s.empty() || min_s.top() >= val) {
            min_s.push(val);
        }
    }
    
    void pop() {
        if (!min_s.empty() && min_s.top() == s.top()) {
            min_s.pop();
        }
        s.pop();    // 注意必须在判断之后！
    }
    
    int top() {
        return s.top();
    }
    
    int getMin() {
        return min_s.top();
    }
};

6.3 解法2

点击这里

这个解法是在 题解 中看到的，不同于前面使用的 [辅助栈]，而是只用了一个栈。

使用一个栈，这个栈同时保存的是每个数字 x 进栈的时候的值 与 插入该值后的栈内最小值。即每次新元素 x 入栈的时候保存一个元组：（当前值 x，栈内最小值）。

这个元组是一个整体，同时进栈和出栈。即栈顶同时有值和栈内最小值， top() 函数是获取栈顶的当前值，即栈顶元组的第一个值； getMin() 函数是获取栈内最小值，即栈顶元组的第二个值；pop() 函数时删除栈顶的元组。

每次新元素入栈时，要求新的栈内最小值：比较当前新插入元素 x 和 当前栈内最小值（即栈顶元组的第二个值）的大小。

新元素入栈：当栈为空，保存元组 (x, x)；当栈不空，保存元组 (x, min(此前栈内最小值， x)))
出栈：删除栈顶的元组。

class MinStack {
private:
    stack<pair<int, int>> s;
public:
    /** initialize your data structure here. */
    MinStack() { }
    
    void push(int x) {
        if (s.size() == 0) {
            s.push({x, x});
        } else {
            s.push({x, min(x, s.top().second)});
        }
    }
    
    void pop() {
        s.pop();
    }
    
    int top() {
        return s.top().first;
    }
    
    int getMin() {
        return s.top().second;
    }
};