面试题：如何用栈实现队列

题目

用栈来模拟一个队列，要求实现队列的两个基本操作：入队、出队

解题方法

栈、队列不同点

栈的特点是先入后出，出入元素都是在同一端（栈顶）。

入栈：

出栈：

队列的特点是先入先出，出入元素是在不同的两端（队头和队

尾）。

入队：

出队：

既然我们拥有两个栈，那么可以让其中一个栈作为队列的入口，负责插入新元素；另一个栈作为队列的出口，负责移除老元素。

实现步骤

队列的主要操作无非有两个：入队和出队。 在模拟入队操作时，每一个新元素都被压入到栈A当中。 让元素1入队。

让元素2入队。

让元素3入队。

这时，我们希望最先入队的元素1出队，需要怎么做呢？让栈A中的所有元素按顺序出栈，再按照出栈顺序压入栈B。这样一来，元素从栈A弹出并压入栈B的顺序是3、2、1，和当初进入栈A的顺序1、2、3是相反的。 

此时让元素1 出队，也就是让元素1从栈B中弹出。

让元素2出队。 

此时，当有新元素入队时，重新把新元素压入栈A。让元素4入队。

此时出队操作仍然从栈B中弹出元素。让元素3出队。

代码实现

package arithmetic.com.ty.binary;

import java.util.Stack;

public class StackQueue {
    private Stack<Integer> stackA = new Stack<Integer>();
    private Stack<Integer> stackB = new Stack<Integer>();

    /**
     * 入队操作
     * 
     * @param element 入队的元素
     */
    public void enQueue(int element) {
        stackA.push(element);
    }

    /**
     * 出队操作
     */
    public Integer deQueue() {
        if (stackB.isEmpty()) {
            if (stackA.isEmpty()) {
                return null;
            }
            transfer();
        }
        return stackB.pop();
    }

    /**
     * 栈A元素转移到栈B
     */
    private void transfer() {
        while (!stackA.isEmpty()) {
            stackB.push(stackA.pop());
        }
    }

    public static void main(String[] args) throws Exception {
        StackQueue stackQueue = new StackQueue();
        stackQueue.enQueue(1);
        stackQueue.enQueue(2);
        stackQueue.enQueue(3);
        System.out.println(stackQueue.deQueue());
        System.out.println(stackQueue.deQueue());
        stackQueue.enQueue(4);
        System.out.println(stackQueue.deQueue());
        System.out.println(stackQueue.deQueue());
    }
}

入队操作的时间复杂度显然是O(1)。至于出队操作，如果涉及栈A和栈B的元素迁移，那么一次出队的时间复杂度是O(n)；如果不用迁移，时间复杂度是O(1)。咦，在这种情况下，出队的时间复杂度究竟应该是多少呢？ 这里涉及一个新的概念，叫作均摊时

间复杂度。需要元素迁移的出队操作只有少数情况，并且不可能连续出现，其后的大多数出队操作都不需要元素迁移。 所以把时间均摊到每一次出队操作上面，其时间复杂度是O(1)。