Stack（篇3）设计一个栈能够在O（1）的时间内getMin

问题：设计一个数据结构SpecialStack，支持所有的栈操作，如push（），pop（），isEmpty（），isFull（）和一个附加的操作getMin（）它应该从SpecialStack返回最小元素。SpecialStack的所有这些操作必须是O（1）。要实现SpecialStack，你应该只使用标准的Stack数据结构，没有其他数据结构，如数组，列表，等等。
例：

请考虑以下SpecialStack
16  - > TOP
15
29
19
18

当getMin（）被调用时，它应返回15，这是最小值 
元素在当前堆栈。 

如果我们在堆栈上弹出两次，堆栈就变成了
29  - > TOP
19
18

当调用getMin（）时，它应该返回18是最小值 
在当前堆栈中。

---

解决方案：

---

使用两个堆栈：一个用于存储实际堆栈元素，另一个用作存储最小值的辅助堆栈。这个想法是以push（）和pop（）操作，使得辅助堆栈的顶部始终是最小的。让我们看看push（）和pop（）操作如何工作。

Push（int x）//将元素x插入到特殊堆栈
1）将x推送到第一个堆栈（具有实际元素的堆栈）
2）将x与第二个堆栈（辅助堆栈）的顶部元素进行比较。让顶部元素为y。
… ..a）如果x小于y，则将x推到辅助堆栈。
… ..b）如果x大于y，则将y推送到辅助堆栈。

int Pop（）//从特殊堆栈中删除一个元素并返回已移除的元素
1）从辅助堆栈弹出顶部元素。
2）从实际堆栈中弹出顶部元素并返回。

步骤1是必要的，以确保辅助堆栈也被更新以用于将来的操作。

int getMin（）//从特殊堆栈返回最小元素
1）返回辅助堆栈的顶部元素。

我们可以看到，所有上述操作都是O（1）。
让我们看一个例子。让我们假设两个堆栈最初是空的，18,19,29,15和16被插入到SpecialStack中。

当我们插入18时，两个堆栈都变为以下。
实际堆栈
18 <---顶     
辅助堆栈
18 <----顶

当插入19时，两个堆栈都将更改为以下。
实际堆栈
19 <---顶     
18
辅助堆栈
18 <----顶
18

当插入29时，两个堆栈都将更改为以下。
实际堆栈
29 <---顶     
19
18
辅助堆栈
18 <----顶
18
18

当插入15时，两个堆栈都将更改为以下。
实际堆栈
15 <---顶     
29
19 
18
辅助堆栈
15 <----顶
18
18
18

当插入16时，两个堆栈都更改为以下。
实际堆栈
16 <---顶     
15
29
19 
18
辅助堆栈
15 <----顶
15
18
18
18

---

代码

---

import java.util.Stack;


public class StackMin {

    Stack<Integer> stack=new Stack<Integer>();
    Stack<Integer> minStack=new Stack<Integer>();
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int [] pushA={1,2,3,4,5};int [] popA={4,5,3,1,2};
        System.out.println(IsPopOrder(pushA,popA));
    }
    public static  boolean IsPopOrder(int [] pushA,int [] popA) {

        Stack<Integer> stack=new Stack<Integer>();
        int j=0;
        for(int i=0;i<popA.length;i++)
         {  
            if(!stack.isEmpty()&&(stack.peek()==popA[i]))
            {
                stack.pop();
            }
            else {

                while(j<pushA.length&&(pushA[j]!=popA[i]))
                {
                    stack.push(pushA[j]);
                    j++;
                }
                if(j==pushA.length)
                    return false;
                else {
                    j++;
                }
            }           
         }

        return true;
    }
    public void push(int node) {
        stack.push(node);
        if(minStack.isEmpty())
        {
            minStack.push(node);
        }
        else {
            if(node<=minStack.peek())
                minStack.push(node);
        }
    }

    public void pop() {   
        if(minStack.peek()==stack.peek())
            minStack.pop();
        stack.pop(); 
    }

    public int top() {
        return stack.peek();
    }

    public int min() {

        return minStack.peek();

    }
}

getMin()时间复杂度为O（1）空间复杂度为O（n）
下一篇中将实现getMin()时间复杂度为O（1）空间复杂度为也为O（1）。
Stack（篇2）设计一个栈能在O（1）的时间和O（1）的空间getMin（）