两个栈实现一个队列

建了博客，可是一个字也没写过。今天写这个练手的简单小题目，看看会不会被砖头拍死。两个栈实现一个队列，不考虑效率的确不是什么难事。于是，我懒得做任何优化，只是尽量把代码写干净一点，用Java。接口和java.util.Queue类似（可能不是完全一样）：offer方法表示入队，poll方法表示出队，peek方法是提取队头元素，empty方法检测队列是否为空。

思路很简单——我看了题目很快就能想出来思路的，想必是不难。想象两个栈A和B，一开始里面都没有元素。

入队(offer)时，只是在A中压入相应的元素。

出队(poll)时，由于需要的是A底部的元素，所以把A种的元素逐个弹出放入B中，就可以把顺序颠倒过来，使得A的底部元素成为B的顶部元素(ensureDequeue方法和exchangeStack方法)。

访问队列顶部元素(peek)和出队很接近，不用单独说了。

回到入队，如果B不是空的，那么需要和出队相反的操作(ensureEnqueue方法)。布尔变量mEnqueue用来区分当前是处于入队还是出队的状态，这样就可以决定要不要调用exchangeStack方法来”倾倒“某个栈。

import java.util.Stack;

class MyQueue<T> {
private Stack<T> mStackEnqueue;
private Stack<T> mStackDequeue;
private boolean mEnqueue;

public MyQueue() {
mStackEnqueue = new Stack<T>();
mStackDequeue = new Stack<T>();
mEnqueue = true;
}

public void offer(T value) {
ensureEnqueue();
mStackEnqueue.push(value);
}

public T poll() {
ensureDequeue();
if (mStackDequeue.empty()) return null;
return mStackDequeue.pop();
}

public T peek() {
ensureDequeue();
if (mStackDequeue.empty()) return null;
return mStackDequeue.peek();
}

public boolean empty() {
if (mEnqueue) {
return mStackEnqueue.empty();
}
return mStackDequeue.empty();
}

private void ensureEnqueue() {
if (!mEnqueue) {
exchangeStack(mStackDequeue, mStackEnqueue);
mEnqueue = true;
}
}

private void ensureDequeue() {
if (mEnqueue) {
exchangeStack(mStackEnqueue, mStackDequeue);
mEnqueue = false;
}
}

private void exchangeStack(Stack<T> src, Stack<T> dst) {
assert dst.empty();
while (!src.empty()) {
T tmp = src.pop();
dst.push(tmp);
}
}
}

public class Stack2Queue {
public static void main(String[] args) {
System.out.println("Start testing MyQueue");
MyQueue<Integer> myQueue = new MyQueue<Integer>();
assert myQueue.empty();
int length = 10;
// enqueue
for (int k = 0; k < length; ++k) {
myQueue.offer(Integer.valueOf(k));
assert myQueue.peek().intValue() == 0;
assert !myQueue.empty();
}

// dequeue
for (int k = 0; k < length; ++k) {
assert myQueue.peek().intValue() == k;
assert !myQueue.empty();
Integer kWrapped = myQueue.poll();
assert kWrapped.intValue() == k;
}

// dequeue when queue is empty
assert myQueue.empty();
Integer nullInteger = myQueue.poll();
assert nullInteger == null;
assert myQueue.empty();

// interleaved enqueue and dequeue
for (int k = 0; k < length; ++k) {
myQueue.offer(Integer.valueOf(k));
}
for (int k = 0; k < length; ++k) {
myQueue.offer(Integer.valueOf(k + length));
Integer kWrapped = myQueue.poll();
assert kWrapped.intValue() == k;
}
for (int k = 0; k < length; ++k) {
Integer kWrapped = myQueue.poll();
assert kWrapped.intValue() == k + length;
}
System.out.println("Finish testing MyQueue");
}
}

我用了一堆assert来测试，只是因为我好久不用assert了。Java里直接写上assert是不够的，需要把你虚拟机的断言支持打开，网上一搜一堆，不再赘述。写完这段小程序，上网查了一下，发现可以优化的地方还是有的。比如：

mEnqueue这个状态变量可以拿掉，直接用两个栈是否为空来作为判断当前状态的条件。

exchangeStack方法中，不用把某一个栈完全倒空。比如，A中有若干元素，此时需要出队，那么出栈时A中的最后一个元素不用放到B中，直接拿出来就是要出队的元素。这样操作之后，两个栈的状态不会和上面给出的程序有任何不同，但是省了一次入栈操作。

如此等等。但是，我始终觉得这个问题充其量只能练练手，没有实用价值。当你入队N个元素，然后交替进行入队和出队操作，麻烦就来了。因为每一次操作，都需要对Θ(n)个元素做一次出栈和入栈操作，费力不讨好。