用队列实现栈；用栈实现队列

图的广度优先遍历需要用到栈，但有时题目会要求你不能使用栈，这是就需要用两个队列实现栈，然后用这个栈来实现图的广度优先遍历。

用两个队列实现栈的基本思路：

• 数据push时只进data队列；
• 数据pop时先将data中的数据倒入help队列中，留最后一个在data队列中，然后返回给用户，最后data和help队列的指针交换一下；
• 数据peek时方法和pop一样，只是peek的数据还需要入help队列；

import java.util.LinkedList;
import java.util.Queue;

public class StackAndQueueConvert {

    public static class TwoQueueStack{

        private Queue<Integer> data;
        private Queue<Integer> help;

        public TwoQueueStack(){
            data=new LinkedList<>();
            help=new LinkedList<>();
        }

        public void push(int obj){
            data.add(obj);
        }

        public int pop(){
            if(data.isEmpty()){
                throw new RuntimeException("Stack is empty");
            }
            while (data.size()>1){//要返回的数还要留在data队列中
                help.add(data.poll());
            }
            int res=data.poll();
            swap();
            return res;
        }

        public int peek(){
            if(data.isEmpty()){
                throw new RuntimeException("Stack is empty");
            }
            while (data.size()>1){//要返回的数还要留在data队列中
                help.add(data.poll());
            }
            int res=data.poll();
            help.add(res);//返回的数还要放回help队列中
            swap();
            return res;
        }

        //交换两个队列的指针
        private void swap(){
            Queue<Integer> temp=help;
            help=data;
            data=temp;
        }
    }

    public static void main(String[] args) {
        TwoQueueStack qStack = new TwoQueueStack();
        qStack.push(1);
        qStack.push(2);
        qStack.push(3);

        while (!qStack.data.isEmpty()) {
            System.out.println(qStack.pop());
        }

    }
}

用两个栈结构实现队列

用两个栈结构实现队列时从push栈往pop栈倒数据时需要满足以下两个原则：

• 原则一、push栈往pop栈倒数据时一定要倒完
• 原则二、pop栈还有数据时，push栈不能往pop栈中倒数据

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class StackAndQueueConvert {
    //使用栈结构实现队列
    public static class TwoStackQueue{

        private Stack<Integer> stackPush;
        private Stack<Integer> stackPop;

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

        public void push(int obj){
            stackPush.push(obj);
        }

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

        public int peek(){
            if(stackPop.isEmpty() && stackPush.isEmpty()){
                throw new RuntimeException("Queue is empty");
            }
            daoData();
            return stackPop.peek();
        }

        public void daoData(){
            if(!stackPop.isEmpty()){ //原则一：只有在stackPop栈空的时候才可以往里倒数据
                return;
            }
            while (!stackPush.isEmpty()){ //原则二：stackPush栈往pop栈倒数据时，一定要倒完
                stackPop.push(stackPush.pop());
            }
        }
    }

    public static void main(String[] args) {
        TwoStackQueue squeue = new TwoStackQueue();
        squeue.push(1);
        squeue.push(2);
        squeue.push(3);
        int res = squeue.pop();
        System.out.println(res);
        squeue.push(4);
        res = squeue.pop();
        System.out.println(res);
    }
}