利用栈模拟队列和利用队列模拟栈

问题1：使用2个栈模拟队列
思路：
入栈到stack1。
出栈时判断stack2是否有元素，如果没有，判断stack1是否有元素，
如果没有队列为空，如果stack1有元素，将stack1中元素出栈，再入栈到stack2，
如果stack2有元素，直接出栈。

代码：

import java.util.Stack;

class MyQueue{
    private Stack<Integer> stack1;
    private Stack<Integer> stack2;
    public MyQueue() {
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    }
    public void push(int x){//谁为空，谁入栈
       stack1.push(x);
    }
    public int pop(){
    if(empty()){
        System.out.println("空队列");
        return -1;
    }
    if(stack2.empty()){
            while(!stack1.empty()){
               stack2.push(stack1.pop());
            }
        }
    return stack2.pop();
    }
    public int top(){
        if(empty()){
            System.out.println("空队列");
            return -1;
        }
        if(stack2.empty()){
            while(!stack1.empty()){
                stack2.push(stack1.pop());
            }
        }
        return stack2.peek();
    }
    public boolean empty(){
        if(stack1.empty()&&stack2.empty()){
            return true;
        }
        return false;
    }
}
public class TestDemo {
    public static void main(String[] args) {
    MyQueue qu1=new MyQueue();
    qu1.push(1);
    qu1.push(2);
    qu1.push(3);
        System.out.println(qu1.top());//1
        System.out.println(qu1.pop());//1
        System.out.println(qu1.top());//2
    }
}

问题2：利用两个队列模拟栈
思路：
哪个队列为空，哪个队列入队，都为空queue1入队。
出队时，哪个队不为空，先将这个队列的元素出队的只剩一个，将这些元素入队到另一个队，然后将最后一个元素出队。如果两个队列都为空，则栈为空。

代码：

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

class MyStack{
    private Queue<Integer> queue1;
    private Queue<Integer> queue2;
    public MyStack(){
        queue1=new LinkedList<>();
        queue2=new LinkedList<>();
    }
    public void push(int x){//哪个队列为空，哪个队列入队,都为空queue1入队
        if(!queue1.isEmpty()){
            queue1.offer(x);
        }else if(!queue2.isEmpty()){
            queue2.offer(x);
        }else{
            queue1.offer(x);
        }
    }
    public int pop() {
        int qSize1 = queue1.size();
        int qSize2 = queue2.size();
        int data = 0;
        if (empty()) {
            System.out.println("空栈");
            return -1;
        }
        if (!queue1.isEmpty()) {
            for (int i = 0; i < qSize1-1; i++) {//出栈的只剩一个元素
                queue2.offer(queue1.poll());
            }
            data=queue1.poll();
        } else{
            for (int i = 0; i < qSize2-1; i++) {//出栈的只剩一个元素
                queue1.offer(queue2.poll());
            }
            data=queue2.poll();
        }
        return data;
    }
    public int peek(){
        int qSize1 = queue1.size();
        int qSize2 = queue2.size();
        int data = 0;
        if (empty()) {
            System.out.println("空栈");
            return -1;
        }
        if (!queue1.isEmpty()) {
            for (int i = 0; i < qSize1; i++) {
                data=queue1.poll();
                queue2.offer(data);
            }
        }
        if (!queue2.isEmpty()) {
            for (int i = 0; i < qSize2; i++) {
                data=queue2.poll();
                queue1.offer(data);
            }
        }
        return data;
    }
    public boolean empty(){
        return queue1.isEmpty()&&queue2.isEmpty();
    }
}
public class TestDemo {
    public static void main(String[] args) {
    MyStack stack=new MyStack();
    stack.push(1);
    stack.push(2);
    stack.push(3);
        System.out.println(stack.peek());//3
        System.out.println(stack.pop());//3
        System.out.println(stack.peek());//2
    }
}