两个栈实现一个队列和两个队列实现一个栈（java实现）

两个栈实现一个队列：

首先要清楚栈的特点是后进先出，然后队列的特点是先进先出，这样的话，用两个栈就可以实现队列的特性，存储的时候可以先存储到一个负责周转的栈，然后在取值的时候再将这个栈的数据依次出栈放到另外一个栈里，就可以实现先进先出的特性。

public class TwoStackToQueue<T> {
    private Stack<T> stack1;
    private Stack<T> stack2;
    public TwoStackToQueue(){
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    }
    public void push(T value){
        stack1.push(value);
    }
    public T pop(){
        while(!stack1.isEmpty()){
            stack2.push(stack1.pop());
        }
        T result = stack2.pop();
        while(!stack2.isEmpty()){
            stack1.push(stack2.pop());
        }
        return result;
    }
    public T peek(){
        while(!stack1.isEmpty()){
            stack2.push(stack1.pop());
        }
        T result = stack2.peek();
        while(!stack2.isEmpty()){
            stack1.push(stack2.pop());
        }
        return result;
    }
    public boolean isEmpty(){
        if(stack1.isEmpty()){
            return true;
        }
        return false;
    }
}

两个队列实现一个栈：

实现的关键点是，队列是先进先出，而栈是后进先出，因此想要用队列实现栈在存值的时候存入其中一个队列，在获取栈顶值的时候将存储数据的队列中的元素输出至只剩队尾一个元素，然后将该元素返回输出，根据队列的特性，该元素就是最后放入队列中的元素，从而达到后进先出的目的。
使用的队列类是上述所写类

class TwoQueueToStack<T>{
    private TwoStackToQueue<T> queue1;//负责存储值
    private TwoStackToQueue<T> queue2;
    public TwoQueueToStack(){
        queue1 = new TwoStackToQueue<>();
        queue2 = new TwoStackToQueue<>();
    }
    public void push(T value){
        queue1.push(value);
    }
    public T pop(){
        T value;
        while(true){
            value = queue1.pop();
            if(queue1.isEmpty()){
                break;
            }
            queue2.push(value);
        }
        queue1 = queue2;
        queue2 = new TwoStackToQueue<>();
        //queue2只是作为一个中转的工具，因此之后重新赋空
        return value;
    }
    public T peek(){
        T value = null ;
        while(!queue1.isEmpty()){
            value = queue1.pop();
            queue2.push(value);
        }
        queue1 = queue2;
        queue2 = new TwoStackToQueue<>();
        //queue2只是作为一个中转的工具，因此之后重新赋空

        return value;
    }

    public boolean isEmpty(){
        if(queue1.isEmpty()){
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        TwoQueueToStack<Integer> t = new TwoQueueToStack<>();
        t.push(5);
        t.push(4);
        t.push(3);
        t.push(2);
        t.push(1);
        while(!t.isEmpty()){
            System.out.println(t.pop());
        }
    }

}