Java基础：两个栈实现队列，两个队列实现栈

练习一：两个栈实现队列

思路：

1. 两个栈，一个作为push栈，一个作为pop栈。
2. 数据push直接push到push栈中。
3. 数据pop，从pop栈中pop，pop栈数据为空时，从push栈中pop出所有数据进入pop栈

package com.miracle.study.qs;

import org.junit.jupiter.api.Test;

import java.util.Stack;

/**
 * 两个栈实现队列（先进先出）
 * @author Miracle
 * @date 2021/4/9 19:48
 */
public class StackToQueue<T> {

    /**
     * push栈，主要用于添加数据
     */
    private Stack<T> pushStack;

    /**
     * pop栈，主要用于弹出数据
     */
    private Stack<T> popStack;

    public StackToQueue(){
        pushStack = new Stack<>();
        popStack = new Stack<>();
    }

    public void add(T t){
        pushStack.push(t);
    }

    public T poll(){
        // 判断pop栈是否有数据，再判断push栈是否存有数据，如果是将push栈数据导入pop栈
        if (popStack.isEmpty() && !pushStack.isEmpty()){
            while (pushStack.size() > 0){
                popStack.push(pushStack.pop());
            }
            return popStack.pop();
        // 判断pop栈是否有数据，有数据则直接将数据弹出
        } else if (!popStack.isEmpty()){
            return popStack.pop();
        } else {
            return null;
        }

    }

    @Test
    public void test(){
        var sq = new StackToQueue<Integer>();
        sq.add(1);
        sq.add(2);
        System.out.println(sq.poll());
        System.out.println(sq.poll());
    }
}

练习二：两个队列实现栈

思路：

1. 两个队列，分为pop队列与push队列，两个队列每次pop都需要互换一次身份。
2. 添加数据，判断哪个队列存在数据就往哪个队列添加数据。
3. 弹出数据，判断哪个队列为空队列，将另外一个队列的数据除最后一个数据全部导入到另一个队列中，剩下的最后一个数据弹出。

package com.miracle.study.qs;

import org.junit.jupiter.api.Test;

import java.util.LinkedList;

/**
 * 双队列实现栈（先进后出）
 * @author Miracle
 * @date 2021/4/9 19:25
 */
public class QueueToStack<T> {

    /**
     * pop队列或push队列
     */
    private LinkedList<T> q1;

    /**
     * pop队列或push队列
     */
    private LinkedList<T> q2;

    public QueueToStack(){
        q1 = new LinkedList<>();
        q2 = new LinkedList<>();
    }

    public void push(T t){
        // 判断那个队列存在数据，就往哪个队列插入数据
        if (q1.size() > 0){
            q1.addLast(t);
            return;
        }
        q2.addLast(t);

    }

    public T pop(){
        // 判断两个队列是否都是空
        if (q2.isEmpty() && q1.isEmpty()){
            return null;
        }
        LinkedList<T> pushList;
        LinkedList<T> popList;
        // 判断q2是不是空
        if (q2.isEmpty()){
            // 设置q1为pop队列
            popList = q1;
            // 设置q2为push队列
            pushList = q2;
        }else {
            // 设置q1为pop队列
            popList = q2;
            // 设置q1为push队列
            pushList = q1;
        }
        // 循环将pop的数据弹出到push队列中，最后一个数据输出
        while (popList.size() > 1){
            pushList.addLast(popList.pop());
        }
        return popList.pop();
    }

    @Test
    public void test(){
        var qs = new QueueToStack<Integer>();
        qs.push(1);
        qs.push(2);
        qs.push(3);
        qs.push(4);

        System.out.println(qs.pop());
        qs.push(5);
        System.out.println(qs.pop());
    }
}