算法-leetcode-栈和队列- 232. 用栈实现队列

21, 232. 用栈实现队列

https://leetcode-cn.com/problems/implement-queue-using-stacks/

思路1: 通过两个栈实现队列

• resultStack同时充当入栈出栈对象
• resultStack中的顺序通过两个栈的多次交换实现 队列顺序

package com.shangguigu.dachang.algrithm.A07_queue_and_stack;

import java.util.Stack;

/**
 * @author : 不二
 * @date : 2022/4/16-上午9:10
 * @desc : 232. 用栈实现队列
 * https://leetcode-cn.com/problems/implement-queue-using-stacks/
 *
 * 这里和队列实现栈类似：
 * 思路1也可以通过两个栈实现
 *
 *
 **/
public class A69_queue_by_stack_v1 {

    public static void main(String[] args) {
        A69_queue_by_stack_v1 myQueue = new A69_queue_by_stack_v1();
        myQueue.push(1); // queue is: [1]
        myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
        System.out.println(myQueue.peek()); // return 1
        System.out.println(myQueue.pop()); // return 1, queue is [2]
        System.out.println(myQueue.empty());// return false


    }

    Stack<Integer> resultStack;
    Stack<Integer> tmpStack;

    public A69_queue_by_stack_v1(){
        resultStack = new Stack<>();
        tmpStack = new Stack<>();
    }


    public void push(int x){
        while (resultStack.size() > 0) {
            tmpStack.push(resultStack.pop());
        }

        resultStack.push(x);

        while (tmpStack.size() > 0) {
            resultStack.push(tmpStack.pop());
        }
    }

    public int pop(){
        return resultStack.pop();
    }

    public int peek(){
        return resultStack.peek();
    }

    public boolean empty(){
        return resultStack.isEmpty();
    }
}

思路2: 思路1优化：两个栈分别充当入栈对象和出栈对象，分工处理

• 思路1中交换是多次的
• 本思路中：我们把tmpStack作为入栈对象，resultStack作为出栈对象。

package com.shangguigu.dachang.algrithm.A07_queue_and_stack;

import java.util.Stack;

/**
 * @author : 不二
 * @date : 2022/4/16-上午9:10
 * @desc : 232. 用栈实现队列
 * https://leetcode-cn.com/problems/implement-queue-using-stacks/
 *
 * 这里和队列实现栈类似：
 * 思路1也可以通过两个栈实现
 *
 * 思路1的话，交换次数还是太多了
 * 那么可以更改个思路：
 *      我入栈的时候入栈到tmpStack
 *      出栈的时候从resultStack出，
 *      如果resultStack个数为0，那么就把tmpStack出栈然后再入栈到resultStac， resultStac再出
 *      这样就不需要多轮的交换了
 *
 **/
public class A69_queue_by_stack_v2 {

    public static void main(String[] args) {
        A69_queue_by_stack_v2 myQueue = new A69_queue_by_stack_v2();
        myQueue.push(1); // queue is: [1]
        myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
        System.out.println(myQueue.peek()); // return 1
        System.out.println(myQueue.pop()); // return 1, queue is [2]
        System.out.println(myQueue.empty());// return false


    }

    Stack<Integer> resultStack;
    Stack<Integer> tmpStack;

    public A69_queue_by_stack_v2(){
        resultStack = new Stack<>();
        tmpStack = new Stack<>();
    }


    // 我入栈的时候入栈到tmpStack
    public void push(int x){
        tmpStack.push(x);
    }

    // 出栈的时候从resultStack出，如果resultStack个数为0，那么就把tmpStack出栈然后再入栈到resultStac， resultStac再出
    public int pop(){
        if (resultStack.size() == 0) {
            while (tmpStack.size() > 0) {
                resultStack.push(tmpStack.pop());
            }
        }
        return resultStack.pop();
    }

    public int peek(){
        if (resultStack.size() == 0) {
            while (tmpStack.size() > 0) {
                resultStack.push(tmpStack.pop());
            }
        }
        return resultStack.peek();
    }

    public boolean empty(){
        if (resultStack.size() == 0) {
            while (tmpStack.size() > 0) {
                resultStack.push(tmpStack.pop());
            }
        }
        return resultStack.isEmpty();
    }
}