包含min、max函数的栈

这是google的一道面试题：定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的函数。在该栈中，调用min,push,pop的时间复杂度都是O(1)。下面就分析了一下min函数，max函数同理可得。

template <typename T>
class min_stack
{
    public:
        min_stack(){};
        ~min_stack(){};
        T my_min();
        void my_push(const T& data);
        void my_pop();
        void Show_min_stack(void);
    protected:
    private:
        stack<T> data_stack;
        stack<T> auxi_stack;
};

解决思路：使用两个栈，数据栈data_stack，以及auxi_stack辅助栈。

1、首先在两个栈都为空的时候入栈，然后对于压入的元素，比较其和辅助栈栈顶元素，如果小于栈顶，则该元素同时压入两个栈；

2、否则，该元素压入数据栈，而辅助栈中将辅助栈的顶部元素再次压入一次，这样保证了两个栈的大小相等；

3、在pop的时候同步出栈，辅助栈的栈顶元素始终是最小的元素。这样需要的空间就是两个相等的栈 。

push函数

template <typename T>  
void min_stack<T>::my_push(const T& data)  
{  
    data_stack.push(data);  
    if(auxi_stack.empty() || data < auxi_stack.top())  
        auxi_stack.push(data);  
    else 
        auxi_stack.push(auxi_stack.top());  
}  

pop函数

 template <typename T>  
void min_stack<T>::my_pop()  
{  
    if (auxi_stack.empty() && data_stack.empty())  
        return;  
    else 
    {  
        auxi_stack.pop();  
        data_stack.pop();  
    }  
}  

min函数

template <typename T>  
T min_stack<T>::my_min()  
{  
    assert(!auxi_stack.empty() && ！data_stack.empty())  
    return auxi_stack.top;  
}  

完整程序

#include<stack>   
#include<iostream>   
using namespace std;  
template <typename T>  
class min_stack  
{  
    public:  
        min_stack(){};  
        ~min_stack(){};  
        T my_min();  
        void my_push(const T& data);  
        void my_pop();  
        void Show_min_stack(void);  
    protected:  
    private:  
        stack<T> data_stack;  
        stack<T> auxi_stack;  
};  
template <typename T>  
void min_stack<T>::Show_min_stack(void)  
{  
    stack<T> temp(data_stack);  
    cout<<"\n从栈顶到栈底显示栈数据：\n";  
    while(!temp.empty())  
    {  
        cout<<temp.top()<<"  ";  
        temp.pop();  
    }  
    cout<<"\n最小的数据为：\n";  
    cout<<auxi_stack.top()<<endl;  
}  
template <typename T>  
void min_stack<T>::my_pop()  
{  
    if (auxi_stack.empty() && data_stack.empty())  
        return;  
    else 
    {  
        auxi_stack.pop();  
        data_stack.pop();  
    }  
}  
template <typename T>  
void min_stack<T>::my_push(const T& data)  
{  
    data_stack.push(data);  
    if(auxi_stack.empty() || data < auxi_stack.top())  
        auxi_stack.push(data);  
    else 
        auxi_stack.push(auxi_stack.top());  
}  
template <typename T>  
T min_stack<T>::my_min()  
{  
    if(!auxi_stack.empty())  
        return auxi_stack.top();  
    else 
        return -1;  
}  
int main()  
{  
    min_stack<int> my_min_stack;  
    for(int i=1991;i<1997;i++)  
        my_min_stack.my_push(i);  
    my_min_stack.Show_min_stack();  
   
   
    my_min_stack.my_push(22);  
    my_min_stack.Show_min_stack();  
   
   
    for(int j=0;j<5;j++)  
        my_min_stack.my_pop();  
    my_min_stack.Show_min_stack();  
   
    my_min_stack.my_push(2);  
    my_min_stack.my_push(1);  
    my_min_stack.Show_min_stack();  
}  

运行结果：

  

从栈顶到栈底显示栈数据：

1996  1995  1994  1993  1992  1991

最小的数据为：

1991

  

从栈顶到栈底显示栈数据：

22  1996  1995  1994  1993  1992  1991

最小的数据为：

22

  

从栈顶到栈底显示栈数据：

1992  1991

最小的数据为：

1991

  

从栈顶到栈底显示栈数据：

1  2  1992  1991

最小的数据为：

1