leetcode 225. 用队列实现栈

225. 用队列实现栈

使用队列实现栈的下列操作：

push(x) – 元素 x 入栈
pop() – 移除栈顶元素
top() – 获取栈顶元素
empty() – 返回栈是否为空
注意:

你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/implement-stack-using-queues
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class MyStack {

    private Queue<Integer> queue1;
    private Queue<Integer> queue2;
    /** Initialize your data structure here. */
    public MyStack() {
        queue1 = new LinkedList<Integer>();
        queue2 = new LinkedList<Integer>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
  	      queue2.offer(x);
        //始终保持queue1有元素，queue2为空
        while(!queue1.isEmpty()){
            queue2.offer(queue1.poll());
        }
        Queue<Integer> temp;
        temp = queue2;
        queue2 = queue1;
        queue1 = temp;
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return queue1.poll();
    }
    
    /** Get the top element. */
    public int top() {
        return queue1.peek();
       

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

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

我们算法tutorial同样出了一道这样的题，这是这道题的答案，与leetcode答案有所区别。
A stack may be implemented using two queues by using the second queue as a buffer. When items are pushed onto the stack they are added onto the end of the queue. Each time an item is popped, the n–1 elements of the first queue must be moved to the second, while the remaining item is returned. The following code is not critical for this question but may be useful in understanding how it works.

泛型

public class QueueStack<T> implements Stack<T> {
	private Queue<T> q1 = new QueueImpl<T>( );
	private Queue<T> q2 = new QueueImpl<T>( );
	public void push (T e ) {
		q1 . enqueue ( e ) ; // O( 1 )
	}
	public T pop ( ) {
		while ( q1.size( ) > 1 ) { // O( n )
			q2.enqueue ( q1.dequeue ( ) ) ;
	}
		swapQueues ( ) ;
		return q2 . dequeue ( ) ;
	}
	private void swapQueues ( ) {
		Queue<T> tempQ = q2 ;
		q2 = q1 ;
		q1 = tempQ ;
	}
}

用栈实现队列：
The amortised cost of the push/pop operations are the same as their singular cost. It is possible to implement a queue using two stacks in a similar fashion. However, each element only has to be copied from one stack to the other at most once during its lifetime. This results in an amortised cost of O(1) for the dequeue operation.
此时push的时间复杂度被平摊了，因为只需要执行一次最坏操作O(n),其余操作都是O(1)。