用两个队列实现栈与用两个栈实现队列

用两个队列实现栈：队列先进先出，插入元素时，放入队列1，队列2为空；删除元素时，为了保证栈的性质，实现后进先出，应当首先把队列1中的前面的元素放入到2中，然后将1中剩余的最后一个元素删除。

class MyStack {
    Deque<Integer> q1 = new ArrayDeque<Integer>();
    Deque<Integer> q2 = new ArrayDeque<Integer>();
    // Push element x onto stack.
    public void push(int x) {
        if(q1.size() == 0) q2.offer(x);
        else if(q2.size() == 0) q1.offer(x);
    }

    // Removes the element on top of the stack.
    public void pop() {
        if(q2.size() == 0 && q1.size() != 0) {
            while(q1.size() > 1) {
                q2.offer(q1.pop());
            }
            q1.pop();
        }
        else if(q1.size() == 0 && q2.size() != 0){
            while(q2.size() > 1) {
                q1.offer(q2.pop());
            }
            q2.pop();
        }
    }

    // Get the top element.
    public int top() {
        int i = 0;
        if(q1.size() != 0) {
            while(q1.size() != 0) {
                i = q1.peek();
                q2.offer(q1.pop());
            }
        }
        else if(q2.size() != 0){
            while(q2.size() != 0) {
                i = q2.peek();
                q1.offer(q2.pop());
            }
        }
        return i;
    }

    // Return whether the stack is empty.
    public boolean empty() {
        return q2.size() == 0 && q1.size() == 0;
    }
}

用两个栈实现队列：栈后进先出，插入元素时，放入栈1，栈2为空；当需要删除元素时，将栈1的元素依次放入到2中，此时2中栈顶的元素应当为第一个进入栈1的元素，将其弹出，栈2不为空时，它的栈顶始终都是最先进入栈的元素，此后进入的元素仍然放到1中，当栈2为空时，再要删除元素时就将1中的元素依次pop()，放入到2中。

class MyQueue {
    Stack<Integer> s1 = new Stack<Integer>();
    Stack<Integer> s2 = new Stack<Integer>();
    
    // Push element x to the back of queue.
    public void push(int x) {
        s1.push(x);
    }

    // Removes the element from in front of queue.
    public void pop() {
    if(!s2.empty())
      s2.pop();
    else{
    while(!s1.empty())
     s2.push(s1.pop());

     s2.pop();
  }
}

// Get the front element.
public int peek() {
    if(!s2.empty())
     return s2.peek();
    else{
    while(!s1.empty())
     s2.push(s1.pop());

    return s2.peek();
  }
}

// Return whether the queue is empty.
public boolean empty() {
    if(s1.empty()&&s2.empty())
        return true;
    else
        return false;}
}