剑值offer面试题30：包含main函数的栈

题目描述：定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例:

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

解析思路
由于需要保证时间复杂度为 O(1)，则采用 空间换时间 的方案，使用辅助栈 st_min 进行存储

1、push 操作
数据栈 st：直接 push 数值元素

辅助栈 st_min：如果 st_min 为空或者 x 大于等于st_min 的栈顶元素（min_value），则 x 是最小元素，则将数据栈 st 中最小的元素 push 进辅助栈

2、pop 操作
数据栈 st：直接移除栈顶元素

辅助栈 st_min：判断数据栈 st 中刚移除的栈顶元素是否等于辅助栈 st_min 中的栈顶元素。
如果相等，则出栈的元素是最小元素，则删除辅助栈 st_min 的栈顶元素，否则不执行操作。
目的： 为了让辅助栈中的栈顶元素始终是数据栈中的最小值

3、top 操作
数据栈 st：返回栈顶元素

辅助栈 st_min：不执行操作

4、min 操作
数据栈 st：不执行操作

辅助栈 st_min：返回栈顶元素

根据上述操作，st_min 的元素个数总是少于或等于 st 的元素个数，且 st_min 是单调栈，栈底到栈顶的元素非严格单调递减。

由于当每次入栈的元素是最小元素时，该元素都会入栈 st_min，且 st_min 具有单调性，因此在只有 push 操作的情况下，st_min 的栈顶元素一定是最小元素，min 方法返回的一定是最小元素。

在有 pop 操作的情况下，st_min 的栈顶元素也一定是最小元素，理由如下。

根据 push 和 pop 方法的实现可知，st_min 中的每个元素都在 st 中有一个对应元素，对应元素的含义是，这两个元素（分别属于两个栈）同时入栈和同时出栈。当一个元素从 st_min 出栈时，该元素在 st 中的对应元素同时出栈。

class MinStack {
public:
    stack<int> st,st_min;
    int min_value = INT_MAX; //2^16-1
    /** initialize your data structure here. */
    MinStack() 
    {
    }
    
    void push(int x) 
    {
        st.push(x);
        //如果 x <= min_value ，则更新最小值，并将该值加入辅助栈
        if(min_value >= x)
        {
            min_value = x;
            st_min.push(min_value);
        }         
    }
    
    void pop() 
    {
        if(st.top() == min_value)
        {
            st_min.pop();
            min_value = st_min.size() ? st_min.top() : INT_MAX;
        }
        st.pop();
    }
    
    int top() 
    {
        return st.top();
    }
    
    int min() 
    {
        return min_value;
    }
};

class MinStack {
public:
    stack<int> st,st_min;
    int min_value = INT_MAX; //2^16-1
    /** initialize your data structure here. */
    MinStack() 
    {
         /* 初始化最小栈的栈顶元素为最大值为了防止top访问空指针报错 */
        st_min.push(INT_MAX);
    }
    
    void push(int x) 
    {
        st.push(x);
        //如果 x <= min_value ，则更新最小值，并将该值加入辅助栈
        if(min_value >= x)
        {
            min_value = x;
            st_min.push(min_value);
        }         
    }
    
    void pop() 
    {
        if(st.top() == min_value)
        {
            st_min.pop();
            min_value =  st_min.top() ;
        }
        st.pop();
    }
    
    int top() 
    {
        return st.top();
    }
    
    int min() 
    {
        return st_min.top();
        //return min_value;
    }
};

思路

要做出这道题目，首先要理解栈结构先进后出的性质。

对于栈来说，如果一个元素 a 在入栈时，栈里有其它的元素 b, c, d，那么无论这个栈在之后经历了什么操作，只要 a 在栈中，b, c, d 就一定在栈中，因为在 a 被弹出之前，b, c, d 不会被弹出。

因此，在操作过程中的任意一个时刻，只要栈顶的元素是 a，那么我们就可以确定栈里面现在的元素一定是 a, b, c, d。

那么，我们可以在每个元素 a 入栈时把当前栈的最小值 m 存储起来。在这之后无论何时，如果栈顶元素是 a，我们就可以直接返回存储的最小值 m。

算法

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

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

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

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

class MinStack {
public:
    stack<int> st,st_min;

    /** initialize your data structure here. */
    MinStack() 
    {
        st_min.push(INT_MAX);
    }
    
    void push(int x) 
    {
        st.push(x);
        //：：min的意思是全局作用域符号，当全局变量在局部函数中与其中某个变量重名，那么就可以用：：来区分
        st_min.push(::min(st_min.top(),x));
    }
    
    void pop() 
    {
        st.pop();
        st_min.pop();
    }
    
    int top() 
    {
        return st.top();
    }
    
    int min() 
    {
        return st_min.top();
    }
};

class MinStack {
public:
    stack<int> st,st_min;
    int min_value = INT_MAX; //2^16 - 1

    /** initialize your data structure here. */
    MinStack() 
    {
        st_min.push(INT_MAX);
    }
    
    void push(int x) 
    {
        st.push(x);
        if(min_value >= x)
        {
            min_value = x;
        } 
         st_min.push(min_value);
    }
    
    void pop() 
    {
        st.pop();
        st_min.pop();
        min_value =  st_min.top();  
    }
    
    int top() 
    {
        return st.top();
    }
    
    int min() 
    {
        return min_value;
    }
};

class MinStack {
public:
    stack<int> st,st_min;
    int min_value = INT_MAX; //2^16 - 1

    /** initialize your data structure here. */
    MinStack() 
    {
    }
    
    void push(int x) 
    {
        st.push(x);
        if(min_value >= x)
        {
            min_value = x;
        } 
         st_min.push(min_value);
    }
    
    void pop() 
    {
        st.pop();
        st_min.pop();
        min_value =  st_min.size() ? st_min.top() : INT_MAX;  
    }
    
    int top() 
    {
        return st.top();
    }
    
    int min() 
    {
        return min_value;
    }
};

 不使用辅助栈，栈中存放键值对

 

class MinStack {
public:
    stack<pair<int,int>> st; 
    int min_value = INT_MAX;

    /** initialize your data structure here. */
    MinStack() 
    {
    }
    
    void push(int x) 
    {
        min_value = ::min(min_value,x);
        st.push({x,min_value});
    }
    
    void pop() 
    {       
        st.pop();
        //min_value = st.size() ? st.top().second : INT_MAX;
        if(st.empty()) min_value = INT_MAX;
        else min_value = st.top().second;
    }
    
    int top() 
    {
        return st.top().first;
    }
    
    int min() 
    {
        //return st.top().second;
        return min_value;
    }
};