leetcode 232. Implement Queue using Stacks（用栈实现队列）

Implement a first in first out (FIFO) queue using only two stacks. The implemented queue should support all the functions of a normal queue (push, peek, pop, and empty).

Implement the MyQueue class:

void push(int x) Pushes element x to the back of the queue.
int pop() Removes the element from the front of the queue and returns it.
int peek() Returns the element at the front of the queue.
boolean empty() Returns true if the queue is empty, false otherwise.
Notes:

You must use only standard operations of a stack, which means only push to top, peek/pop from top, size, and is empty operations are valid.
Depending on your language, the stack may not be supported natively. You may simulate a stack using a list or deque (double-ended queue) as long as you use only a stack’s standard operations.

Example 1:

Input
[“MyQueue”, “push”, “push”, “peek”, “pop”, “empty”]
[[], [1], [2], [], [], []]
Output
[null, null, null, 1, 1, false]

Explanation
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

用2个栈实现一个队列。

思路：

push的操作都是一样的，就是pop不一样。
栈的pop是取出最后放进去的数字，
而队列是取出最先放进去的数字。

用栈实现队列的话，就需要pop的时候每次都把所有元素取出来，返回第一个元素，再把所有元素放回去。
那不如在push的时候就排好，每次push的时候，把所有元素取出来，把最后放进去的元素压入栈底，这样最后放进去的元素就是最后取出来。

class MyQueue {
    Stack<Integer> st;
    Stack<Integer> tmp;

    public MyQueue() {
        st = new Stack();
        tmp = new Stack();
    }
    
    public void push(int x) {
        while(!st.isEmpty()) {
            tmp.push(st.pop());
        }

        st.push(x);

        while(!tmp.isEmpty()) {
            st.push(tmp.pop());
        }
    }
    
    public int pop() {
        return st.pop();
    }
    
    public int peek() {
        return st.peek();
    }
    
    public boolean empty() {
        return st.isEmpty();
    }
}