算法2--由两个栈组成的队列

由两个栈组成的队列

【题目】编写一个类，用两个栈实现队列，支持队列的基本操作（add、poll、peek）。
【思路】
维护两个栈，里面分别存压入栈的数据–需要考虑情况
1．如果 stackPush 要往 stackPop 中压入数据，那么必须一次性把 stackPush 中的数据全部压入。
2．如果 stackPop 不为空，stackPush 绝对不能向 stackPop 中压入数据。
【代码】

/**
 * @auther Jack
 * @create 2020-10-29-19:46
 *
 * 【题目】
 * 编写一个类，用两个栈实现队列，支持队列的基本操作（add、poll、peek）。
 *
 * 1．如果 stackPush 要往 stackPop 中压入数据，那么必须一次性把 stackPush 中的数据全部压入。
 * 2．如果 stackPop 不为空，stackPush 绝对不能向 stackPop 中压入数据。
 * 【思路】
 * 维护两个栈，里面分别存压入栈的数据--需要考虑情况
 * 1.push里面的数据，要换到pop里面，这样直接从pop里面弹出，才是正确的序列
 * 2.354121，这几个数字如果压栈，
 */
public class Test_2 {

    public static void main(String[] args) {
        TwoStacksQueue stack1 = new TwoStacksQueue();
        //第一次add之后，也就是说，把最外面的数据，放到了pop里面，然后不在push里面维护第一个进去的数字
        stack1.add(3);
        //这是连续的add，此时不用往pop里面放
        stack1.add(4);
        stack1.add(5);
        stack1.add(1);
        //这个时候要进行poll，直接拿掉pop里面唯一的值
        System.out.println(stack1.poll());
        //这个时候pop为空，那么再调用的时候，会再pushToPop这个方法，然后把栈底的一个数，放到pop里面
        System.out.println(stack1.poll());
        //因为pop为空，那么这个时候add的时候，会把所有的push都给到pop里面
        stack1.add(2);
        stack1.add(1);
//        这个时候再进行poll的时候，直接从pop里面拿数据
        System.out.println(stack1.poll());
    }
}

class TwoStacksQueue{

    public Stack<Integer> stackPush;
    public Stack<Integer> stackPop;

    TwoStacksQueue(){
        stackPush = new Stack<Integer>();
        stackPop = new Stack<Integer>();
    }
    public void add(int newNum){
        this.stackPush.push(newNum);
        //思考。压第一次栈的时候，就把数据到pop里面了，这个时候push里面只有一个数据--怎么想出来的，思维？
        //因为再poll之后，会把这个pop清空。然后再add或者push的时候，会把poll之前的所有数据都，放进pop里面，
        //比如354121----3，放进pop，我们poll之后--会有两个操作
                                    //1.继续poll，那么我们需要在poll之前，把push里面的数据都push到pop里面
                                    //2.继续add，那么我们就在add的时候，把push里面的数据都给pop，然后push里面的数据清空，
                                    //这个时候，pop里面会有再上一次poll到现在的所有数据，然后push被清空。直至等待pop里面的数据为空的时候
                                    //再进行一次pushToPop操作
        pushToPop();
    }

    public void pushToPop(){
        if(stackPop.isEmpty()){
            while (!stackPush.isEmpty()){
                //这里把push里面的数据，直接放到pop里面，不做维护了，因为
                stackPop.push(stackPush.pop());
            }
        }
    }

    public Integer poll(){
        if(stackPush.isEmpty() && stackPop.isEmpty() ){
            throw new RuntimeException("");
        }
        pushToPop();
        return stackPop.pop();
    }

    public Integer peek(){
        if(stackPush.isEmpty() && stackPop.isEmpty() ){
            throw new RuntimeException("");
        }
        pushToPop();
        return stackPop.peek();
    }
}

class TwoStacksQueue1 {
    public Stack<Integer> stackPush;
    public Stack<Integer> stackPop;

    public TwoStacksQueue1() {
        stackPush = new Stack<Integer>();
        stackPop = new Stack<Integer>();
    }

    // push 栈向 pop 栈倒入数据
    private void pushToPop() {
        if (stackPop.empty()) {
            while (!stackPush.empty()) {
                stackPop.push(stackPush.pop());
            }
        }
    }

    public void add(int pushInt) {
        stackPush.push(pushInt);
        pushToPop();
    }

    public int poll() {
        if (stackPop.empty() && stackPush.empty()) {
            throw new RuntimeException("Queue is empty!");
        }
        pushToPop();
        return stackPop.pop();
    }
}