实现一个栈（元素遵守先入后出顺序），能够通过 min 方法在 O(1)时间内获取栈中的最小元素。同时，栈的基本操作：入栈(Push)、出栈(Pop)，也是在O(1)时间内完成的

实现一个栈（元素遵守先入后出顺序），能够通过 min 方法在 O(1)时间内获取栈中的最小元素。同时，栈的基本操作：入栈(Push)、出栈(Pop)，也是在O(1)时间内完成的。

此问题可分析为：

方案一：

建立两个栈，一个用来存放插入的数据datastack，一个用来存放最小的数据minstack；当最小栈不为空时，在datastack中插入一个数据，先用一变量tmp来存放minstack栈顶元素，将插入数据与tmp比较，若插入数据小将插入数据拷贝一份push进minstack栈内，若tmp小再压入minstack栈内，依次重复。

方案二：

只用建一个栈，但每push进一个元素，先于原来较小元素比较，若原来小，将原来数据拷贝一份入栈，接着将刚要入栈的的元素入栈，也就是说，每次要push一个元素进去，首先得判断，先入的是较小元素或其拷贝，然后是要入栈的元素。

 数据结构实现：

#include <iostream>  
#include<stdlib.h>
using namespace std;   
#include <stack>   
template <class T>  
class retmin  
{  
public :  
     void pushmin(const T& x)  
    {  
         _num.push (x);  
          if(!_min.empty ())  
         {  
             T tmp = _min.top ();  
              if( x < tmp)  
             {  
                 _min.push (x);  
             }  
              else  
                 _min.push (tmp);  
         }  
          else  
             _min.push (x);  
           
    }  
     void popmin()  
    {  
         _num.pop ();  
         _min.pop ();  
    }  
  
    T Retmin()  
    {  
          return _min.top ();  
    }  
private :  
    stack<T> _num;  
       stack<T> _min;  
};  
  
  
void Test9()  
{  
    retmin< int> r1;  
    r1.pushmin (5);  
    r1.pushmin (4);  
    r1.pushmin (3);  
    r1.pushmin (6);  
    r1.pushmin (1); 
	r1.pushmin (5);  
    r1.pushmin (4);  
    r1.pushmin (2);  
    r1.pushmin (6);  
    r1.pushmin (1); 
    cout<<r1.Retmin ()<<endl;  
}  
  
int main()  
{  
    Test9(); 
	system("pause");
     return 0;  
}  

java实现

思路1：添加一个成员变量总是保存当前栈中最小的元素。该思路的实现代码大致是这样的：

public class MinStack {
    
    private LinkedList<Integer> stack;
    private int min;// save minimum ele of stack
    
    public int pop(){
        //check pop minimum ele?
    }
    public void push(int ele){
        //check push minimum ele?
    }
    public int getMin(){
        return min;
    }
}

 

这里就会存在一个问题：保存最小元素的 min 属性 与 栈中的最小元素不一致。

比如：当从栈中 pop 最小元素时，那 min 属性就要 保存 次最小元素了。那如何 找到次最小元素，然后赋值给 min 呢？

 因此，问题的关键就是：当只使用一个 min 属性时，如何保证 min 属性 总是 保存的是当前栈中最小的元素？---即： min 代表的最小元素 要与 栈中的最小元素保存一致。一种方式是当pop出最小元素之后，再遍历栈找出次最小的元素，并将之赋值给 min 。但是，由于遍历使得时间复杂度不再是O(1)

 

思路2：

使用一个辅助栈。此方法能够实现在O(1)时间内获取栈中最小的元素，但是缺点是空间复杂度为O(N)

现在有两个栈：一个是保存元素的数据栈，另一个是辅助栈，辅助栈的栈顶总是 当前数据栈中最小的元素。当Push元素时，首先将该元素Push到数据栈，然后再将该元素与辅助栈的栈顶元素比较：如果该元素比辅助栈的栈顶元素小，则将该元素Push到辅助栈中；否则将辅助栈的栈顶元素再Push到辅助栈中。

比如，现在要Push的元素顺序如下：3，4，2，5....   在数据栈 和 辅助栈中保存的元素如下：

 

三，代码实现

代码中使用了 java.util.LinkedList 类作为 栈的实现。

import java.util.LinkedList;

public class MinStack {
    
    private LinkedList<Integer> dataStack;
    private LinkedList<Integer> minStack;
    
    public MinStack() {
        dataStack = new LinkedList<Integer>();
        minStack = new LinkedList<Integer>();
    }
    
    //base operation
    public void push(int ele)
    {
        dataStack.push(ele);
        if(minStack.size() == 0 || ele < minStack.peek())
            minStack.push(ele);
        else
            minStack.push(minStack.peek());
    }
    
    public Integer pop(){
        if(dataStack.isEmpty())
            return null;
        
        assert dataStack.isEmpty() == false && minStack.isEmpty() == false;
        int ele = dataStack.pop();
        minStack.pop();
        return ele;
    }
    
    public Integer min(){
        if(minStack.isEmpty())
            return null;
        return minStack.peek();
    }
    
    //hapjin test
    public static void main(String[] args) {
        MinStack stack = new MinStack();
        
        int[] eles = {3,4,2,5};
        for (int i : eles) {
            stack.push(i);
        }
        System.out.println(stack.min());//2
        System.out.println(stack.pop());//5
        System.out.println(stack.pop());//2
        System.out.println(stack.min());//3
        stack.push(1);
        System.out.println(stack.min());
    }
}