实现一个特殊栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作

/*实现一个特殊栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作
* 要求：1.pop，push，getMain操作的时间复杂度为O（1）；
* 2.设计的栈类型使用现成栈结构
*
* 准备两个栈，Data、min
* min随着Data增长
* 1.当Data压入4，min也压入4（Data压入什么数字min就压入什么数字）
* 2.但是当Data压入5时，*************比较：Data当前的数字与min栈顶数比较，min小，
* min则继续压入4，如果压入的是3，与min比较，Data中的数字比min中栈顶的元素小，则min栈压入3
* 以此类推。
*
* Data正常压栈，min压入小的数字，如果一样大，持续压入原先的数字。每次压栈都要比较；min栈栈底则为最小元素。
* 当弹出数字时，min随着Data弹出。*/

代码如下：

public class Bokeyuan {
    public static class MyStack1{
        private Stack<Integer> stackData;
        private Stack<Integer> stackMin;
        
        public MyStack1() {
            this.stackData=new Stack<Integer>();
            this.stackMin=new Stack<Integer>();
        }
        
        public void push (int newNum) {
            if(this.stackMin.isEmpty()) {
                this.stackMin.push(newNum);
            }else if(newNum<=this.getMin()) {
            this.stackMin.push(newNum);
        }
        this.stackData.push(newNum);
    }

        private int getMin() {
            // TODO 自动生成的方法存根
            if(this.stackMin.isEmpty()) {
                throw new RuntimeException("You stack is empty");
            }
            return this.stackMin.peek();
        }
        
        public int pop() {
            if(this.stackData.isEmpty()) {
                throw new RuntimeException("You stack is empty");
            }
            int value=this.stackData.pop();
            if(value==this.getMin()) {
                this.stackMin.pop();
            }
            return value;
            }
    }
    
    
    //第二种方法
    public static class MyStack2{
        private Stack<Integer> stackData;//Data栈
        private Stack<Integer> stackMin;//Min栈
        
        public MyStack2() {
            this.stackData=new Stack<Integer>();//系统提供的栈结构
            this.stackMin=new Stack<Integer>();
        }
        
        public void push(int newNum) {//最小栈更新
            if(this.stackMin.isEmpty()) {//当最小栈空
                this.stackMin.push(newNum);//压入最小值
            }else if(newNum<this.getMin()) {//当新进的数比min栈顶小
                this.stackMin.push(newNum);//压入当前数
            }else {
                int newMin=this.stackMin.peek();//当min栈顶数值更小
                this.stackMin.push(newNum);//重复压入min栈顶最小值
            }
            this.stackData.push(newNum);//Data栈压入新数
        }

        private int getMin() {//min栈栈顶操作
            // TODO 自动生成的方法存根
            if(this.stackMin.isEmpty()) {
                throw new RuntimeException("You stack is empty");
            }
            return this.stackMin.peek();//peek()返回栈顶不弹出操作
        }
        
        public int pop() {//为空  报错
            if(this.stackData.isEmpty()) {
                throw new RuntimeException("You stack is empty");
            }
            this.stackMin.pop();//否则min弹出
            return this.stackData.pop();//Data弹出
        }
    }
    
    //测试
    public static void main(String[] args) {
        MyStack1 stack1 = new MyStack1();
        stack1.push(3);
        System.out.println(stack1.getMin());
        stack1.push(4);
        System.out.println(stack1.getMin());
        stack1.push(1);
        System.out.println(stack1.getMin());
        System.out.println(stack1.pop());
        System.out.println(stack1.getMin());

        System.out.println("=============");

        MyStack1 stack2 = new MyStack1();
        stack2.push(3);
        System.out.println(stack2.getMin());
        stack2.push(4);
        System.out.println(stack2.getMin());
        stack2.push(1);
        System.out.println(stack2.getMin());
        System.out.println(stack2.pop());
        System.out.println(stack2.getMin());
    }
    }