队列和栈的相互转换

1. 用队列实现栈

描述：

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）

思路：

考虑先进后出使用双队列来实现栈
（1）先定义两个队列，再初始化构造方法（LinkedList）
（2）push入队，要放在不为空的那个队列里，若!qu1，qu1.offer(x)，若!qu2，qu2.offer(x)，若都为空，指定放在qu1里
（3）empty判断栈空，若两个队列都为空则栈空
（4）pop出栈，先判断若栈为空则没法出栈，接下来判断若qu1不为空，循环把除最后一个元素的所有元素出到另一个队列里，再把最后一个元素返回（注：size每次都会变，所以应该吧size先保存起来）
（5）top取栈顶元素，先判断若栈为空则没法出栈，接下来判断若qu1不为空，循环所有元素出到另一个队列里，返回re（刚好保存最后一个元素）

class MyStack {
     Queue<Integer> qu1;
    Queue<Integer> qu2;

    /** Initialize your data structure here. */
    public MyStack() {
        qu1 = new LinkedList<>();
        qu2 = new LinkedList<>();

    }
    
    /** Push element x onto stack. */
    public void push(int x) {
         if(!qu1.isEmpty()){
            qu1.offer(x);
        }else if(!qu2.isEmpty()){
            qu2.offer(x);
        }else{
            qu1.offer(x);
        }

    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        if(empty())    return -1;
        if(!qu1.isEmpty()){
            int ret = -1;
            int len = qu1.size();
            for(int i = 0; i < len - 1; i++){
                ret = qu1.poll();
                qu2.offer(ret);
            }
            return qu1.poll();
        }else{
            int ret = -1;
            int len = qu2.size();
            for(int i = 0; i < len - 1; i++){
                ret = qu2.poll();
                qu1.offer(ret);
            }
            return qu2.poll();
        }
    }
    
    /** Get the top element. */
    public int top() {
        if(empty()){
            return -1;
        } 
        
        if(!qu1.isEmpty()){
            int ret = -1;
            int len = qu1.size();
            for(int i = 0; i < len ; i++){
                ret = qu1.poll();
                qu2.offer(ret);
            }
            return ret;
        }else{
            int ret = -1;
            int len = qu2.size();
            for(int i = 0; i < len ; i++){
                ret = qu2.poll();
                qu1.offer(ret);
            }
            return ret;
        }

    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return qu1.isEmpty() && qu2.isEmpty();
    }
}

2. 用栈实现队列

描述：

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）
 

思路：

考虑使用两个栈来实现队列
（1）先定义两个栈，并用构造器初始化
（2）empty，判断若两个栈都为空则此时队列为空
（3）push入队，我们默认往s1放，s1.push(x);
（4）pop出队，若队列为空直接返回-1，队列不为空把s1所有元素弹出到s2里，s2的栈顶就是队首，把s2栈顶出队即可
（5）peek获取队首元素，若队列为空直接返回-1，队列不为空把s1所有元素弹出到s2里，s2的栈顶就是队首，把s2栈顶peek即可

class MyQueue {

    /** Initialize your data structure here. */
    Stack<Integer> s1;
    Stack<Integer> s2;
    public MyQueue() {
        s1 = new Stack<>();
        s2 = new Stack<>();
    }
    
    /** Push element x to the back of queue. */
    public void push(int x) {
        s1.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        if(empty()) return -1;

        if(s2.isEmpty()){
            while(!s1.isEmpty()){
                s2.push(s1.pop());
            }   
        }
        return s2.pop();
    }
    
    /** Get the front element. */
    public int peek() {
         if(empty()) return -1;

        if(s2.isEmpty()){
            while(!s1.isEmpty()){
                s2.push(s1.pop());
            }   
        }
        return s2.peek();
    }
    
    /** Returns whether the queue is empty. */
    public boolean empty() {
        return s1.isEmpty() && s2.isEmpty();
    }
}