【转】两个栈实现队列 两个队列实现栈
为说明思想，假设队列、栈都很大，不会出现满的情况。
1. 两个栈实现队列
//前提已知：
struct Stack
{
int top; //栈顶指针
int stacksize;//栈的大小
int *s; //栈底指针
};
void InitStack(Stack *s)；
void Push(Stack *s, int k);
int Pop(*s);
int IsStackEmpty(*s);
int IsStackFull(*s);
实现一
思路
s1是入栈的，s2是出栈的。
- 入队列，直接压到s1是就行了
- 出队列，先把s1中的元素全部出栈压入到s2中，弹出s2中的栈顶元素；再把s2的所有元素全部压回s1中
实现二
思路
s1是入栈的，s2是出栈的。保证所有元素都在一个栈里面
- 入队列时：如果s1为空，把s2中所有的元素倒出压到s1中；否则直接压入s1
- 出队列时：如果s2不为空，把s2中的栈顶元素直接弹出；否则，把s1的所有元素全部弹出压入s2中，再弹出s2的栈顶元素
比较：与实现一相比较，出队列时不必每次都捣鼓了。
实现三
思路
s1是入栈的，s2是出栈的。
- 入队列：直接压入s1即可
- 出队列：如果s2不为空，把s2中的栈顶元素直接弹出；否则，把s1的所有元素全部弹出压入s2中，再弹出s2的栈顶元素
比较
与实现二相比较，入队直接入即可，感觉此时已是最优。
参考代码
void EnQueue(Stack *s1, Stack *s2, int k)
{
Push(s1, k);
}
int DeQueue(Stack *s1, Stack*s2)
{
if(IsStackEmpty(s2) == 1)
{
while(IsStackEmpty(s1) == 0)
{
Push(s2, Pop(s1));
}
}
if(IsStackEmpty(s2) == 1)
{
printf("Empty!\n");
}
return Pop(s2);
}
2. 两个队列实现栈
//前提已知
typedef struct queue
{
int queuesize;
int head, tail;
int *q;
}Queue;
void InitQueue(Queue *q);
void EnQueue(Queue *q, int key);
int DeQueue(Queue *q);
int SizeOfQueue(Queue *q);
int IsQueueEmpty(Queue *q);
int IsQueueFull(Queue *q);
实现一
思路
q1是专职进出栈的，q2只是个中转站
- 入栈：直接入队列q1即可
- 出栈：把q1的除最后一个元素外全部转移到队q2中,然后把刚才剩下q1中的那个元素出队列。之后把q2中的全部元素转移回q1中
图示
参考代码
{
EnQueue(q1, k);
}
int Pop(Queue *q1, Queue *q2)
{
int tmp;
if(IsQueueEmpty(q1) == 1)
{
printf("Stack Empty!\n");
}
else
{
while(SizeOfQueue(q1) != 1)
{
EnQueue(q2, DeQueue(q1));
}
tmp = DeQueue(q1);
while(IsQueueEmpty(q2) == 0)
{
EnQueue(q1, DeQueue(q2));
}
return tmp;
}
}
实现二
思路
q1是专职进出栈的，q2只是个中转站。元素集中存放在一个栈中，但不是指定(q1 或 q2)。
定义两个指针：pushtmp:指向专门进栈的队列q1； tmp：指向临时作为中转站的另一个栈q2
- 入栈：直接入pushtmp所指队列即可
- 出栈：把pushtmp的除最后一个元素外全部转移到队列tmp中,然后把刚才剩下q1中的那个元素出队列
比较
实现二，出栈后就不用转移回原来的栈了（图示最后一步），这样减少了转移的次数。
参考代码
void Push(Queue *q1, Queue *q2, int k)
{
Queue *pushtmp;
if(!IsQueueEmpty(q1))
{
pushtmp = q1;
}
else
{
pushtmp = q2;
}
EnQueue(pushtmp, k);
}
int Pop(Queue *q1, Queue *q2)
{
int tmpvalue;
Queue *pushtmp, *tmp;
if(!IsQueueEmpty(q1))
{
pushtmp = q1;
tmp = q2;
}
else
{
pushtmp = q2;
tmp = q1;
}
if(IsQueueEmpty(pushtmp))
{
printf("Stack Empty!\n");
}
else
{
while(SizeOfQueue(pushtmp) != 1)
{
EnQueue(tmp, DeQueue(pushtmp));
}
tmpvalue = DeQueue(pushtmp);
return tmpvalue;
}
}
两年前从网上看到一道面试题：用两个栈（Stack）实现一个队列（Queue）。觉得不错，就经常拿来面试，几年下来，做此题的应该有几十人了。通过对面试者的表现和反应，有一些统计和感受，在此做个小结。
用C++描述，题目大致是这样的：
已知下面Stack类及其3个方法Push、Pop和 Count，请用2个Stack实现Queue类的入队(Enqueue)出队(Dequeue)方法。
class Stack
{
…
public:
void Push(int x); // Push an element in stack;
int Pop(); // Pop an element out of stack;
int Count() const; // Return the number of the elements in stack;
…
};
class Queue
{
…
public:
void Enqueue(int x);
int Dequeue();
private:
Stack s1;
Stack s2;
…
};
这道题应该不算难，比起《编程之美》中微软那些什么“翻烙饼”的面试题，难度上差远了。况且，由于时间关系，我一般也不要求面试者写代码，只描述清楚思路即可。出这道题，主要考察3点：
- 在短时间内，能不能找到解决这道题的足够清晰的思路（思维是否敏捷、清晰）。
- 能不能在单向表述中，清楚地描述自己的思路和想法（表述能力是否达到要求）。
- 对于某些具体细节，能不能考虑到（是否足够细致）。
总体上，以10人为例，实际的结果大致是：
- 8个人可以找到解决答案，2个人无法找到答案（即使进行了必要的提示，曾经有位号称美国MIT深造2年，之后在Google美国公司工作过8个月的兄弟，也没做出来）。
- 8个找到答案的人中，6个找到的方法相同，2个人找到其它变种。
- 在这8个人中，有1个人可以不经提示，同时想到大众方法和变种。
大多数人的思路是：始终维护s1作为存储空间，以s2作为临时缓冲区。
入队时，将元素压入s1。
出队时，将s1的元素逐个“倒入”（弹出并压入）s2，将s2的顶元素弹出作为出队元素，之后再将s2剩下的元素逐个“倒回”s1。
见下面示意图：
上述思路，可行性毋庸置疑。但有一个细节是可以优化一下的。即：在出队时，将s1的元素逐个“倒入”s2时，原在s1栈底的元素，不用“倒入”s2（即只“倒”s1.Count()-1个），可直接弹出作为出队元素返回。这样可以减少一次压栈的操作。约有一半人，经提示后能意识到此问题。
上述思路，有些变种，如：
入队时，先判断s1是否为空，如不为空，说明所有元素都在s1，此时将入队元素直接压入s1；如为空，要将s2的元素逐个“倒回”s1，再压入入队元素。
出队时，先判断s2是否为空，如不为空，直接弹出s2的顶元素并出队；如为空，将s1的元素逐个“倒入”s2，把最后一个元素弹出并出队。
有些人能同时想到大众方法和变种，应该说头脑还是比较灵光的。
相对于第一种方法，变种的s2好像比较“懒”，每次出队后，并不将元素“倒回”s1，如果赶上下次还是出队操作，效率会高一些，但下次如果是入队操作，效率不如第一种方法。我有时会让面试者分析比较不同方法的性能。我感觉（没做深入研究），入队、出队操作随机分布时，上述两种方法总体上时间复杂度和空间复杂度应该相差无几（无非多个少个判断）。
真正性能较高的，其实是另一个变种。即：
入队时，将元素压入s1。
出队时，判断s2是否为空，如不为空，则直接弹出顶元素；如为空，则将s1的元素逐个“倒入”s2，把最后一个元素弹出并出队。
这个思路，避免了反复“倒”栈，仅在需要时才“倒”一次。但在实际面试中很少有人说出，可能是时间较少的缘故吧。
以上几个思路乍看没什么问题了，但其实还是有个细节要考虑的。其实无论什么方法和情况，都要考虑没有元素可供出队时的处理（2个栈都为空的时候，出队操作一定会引起异常）。在实际写代码时，忽略这些判断或异常处理，程序会出现问题。所以，能不能考虑到这些细节，也体现了个人的素养。
个人感觉，这道题确实有助于我鉴别应聘的人。但对于面试，毕竟还是要看面试者的综合素质，一道（或几道）题定生死不可取。
