常考数据结构与算法:设计getMin功能的栈

题目描述

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

 

示例1

输入

[[1,3],[1,2],[1,1],[3],[2],[3]]

返回值

[1,2]

备注:

有三种操作种类，op1表示push，op2表示pop，op3表示getMin。你需要返回和op3出现次数一样多的数组，表示每次getMin的答案

1<=操作总数<=1000000
-1000000<=每个操作数<=1000000
数据保证没有不合法的操作

 

方法：利用辅助栈
解题思路：利用两个栈stackA和stackB,stackA中存储所有元素并负责入栈push()和出栈pop()操作。stackB中存储stackA中所有非严格降序的元素，stackA中最小的元素对应stackB中的栈顶元素。

import java.util.ArrayList;
import java.util.Stack;

public class MinStackMe {
    public static void main(String[] args) {
        MinStackMe minStackMe = new MinStackMe();
        int[][] arr = {{1,3},{1,2},{1,1},{3},{2},{3}};
    }


    private Stack<Integer> stackA = new Stack<>();
    private Stack<Integer> stackB = new Stack<>();
    private ArrayList<Integer> res = new ArrayList<>();

    /**
     *
     * [1,3],[1,2],[1,1],[3],[2],[3]
     *
     *
     * return a array which include all ans for op3
     * @param op int整型二维数组 operator
     * @return int整型一维数组
     */
    public int[] getMinStack (int[][] op) {
        if(null == op){
            return null;
        }

        for (int i = 0; i < op.length; i++) {
            switch(op[i][0]){
                case 1:
                    push(op[i][1]);
                    break;
                case 2:
                    pop();
                    break;
                default:
                    res.add(getMin());
                    break;
            }
        }

        int ret[] = new int[res.size()];
        for (int i = 0; i < res.size(); i++) {
            ret[i] = res.get(i);
            //System.out.println(ret[i]);
        }
        return ret;
    }

    private void push(int x){
        stackA.push(x); //将x压入stackA中
        if(stackB.isEmpty()){ //如果stackB为空，直接压入stackB中
            stackB.push(x);
        }else{
            //如果stackB不为空，且x<=stackB栈顶的元素，则将x压入stackB中
            if(stackB.peek() >= x){
                stackB.push(x);
            }
        }
    }

    private int pop(){
        int x = 0;
        if(!stackA.isEmpty()){
            x = stackA.pop();
        }

        //如果stackA中弹出的栈顶元素等于stackB中栈顶的元素，则弹出stackB中栈顶的元素
        if(x == stackB.peek()){
            stackB.pop();
        }

        return x;
    }

    public int getMin() {    //stackB中存储stackA中都有非严格降序的元素，所以stackA中最小元素对应stackB的栈顶元素。
        return stackB.peek();
    }
}