栈和队列的相互转换

       栈的特点  ：先进后出；队列的特点：先进先出。所以要实现栈和队列的互换，必须互相模拟彼此的特点。

    比如，用两个队列实现栈，一个队列模拟为入栈队列，一个队列模拟为出栈队列，入栈与普通栈相同，而出栈，首先要获得入栈

队列的长度，将入栈队列中的元素除去最后一个元素依次出队，并且同时依次入出栈队列，然后将最后一个入栈队列里的元素出队即

删除，最后把出栈队列中的元素再依次出队入入栈队列，即模拟完成了栈的出栈，先进后出。实现代码如下：

//用队列模拟定义一个栈，利用两个队实现栈的入栈和出栈运算

typedef struct QueueStack
{
 HNode ppush;   //HNode是链式队列结点
 HNode pout;
}QueueStack,*QStack;
void Init_QueueStack(QStack p)
{
 assert(p!=NULL);
 InitQueue(&(p->pout));
 InitQueue(&(p->ppush));
}
bool Push_QueueStack(QStack p,int val)
{
 Push(&(p->ppush),val);
 return true;
}
bool Pop_QueueStack(QStack p,int *rval)
{
 int tmp;
 int length=GetLength(&(p->ppush));

 for(int i=1;i<length;i++)
 {
  Pop(&(p->ppush),&tmp);
  Push(&(p->pout),tmp);
 }
 Pop(&(p->ppush),rval);
 for(int i=1;i<length;i++)
 {
  Pop(&(p->pout),&tmp);
  Push(&(p->ppush),tmp);
 }
 return true;
}

      用两个栈实现队列与上面的算法相似，用栈模拟队列的先进先出的特点。入队同样和普通的入队一样。出队列，首先将入队栈

中的所有元素依次出栈，然后入出队栈中，并将出队栈中的栈顶元素出栈即删除，最后将出队栈中的元素出栈入入队栈中，即模拟完

成了队列的出队，实现代码如下：

//利用两个栈模拟实现一个队的入队和出队运算。
typedef struct StackQueue
{
 SNode push;
 SNode out;
}StackQueue,*SQueue;
void Init_StackQueue(SQueue p)
{
 assert(p!=NULL);
 p->push.next = NULL;
 p->out.next = NULL;
}
bool Push_StackQueue(SQueue p,int val)
{
 Push(&(p->push),val);
 return true;
}
bool Pop_StackQueue(SQueue p,int *rval)
{
 int tmp;
 while(p->push.next!=NULL)
 {
  Pop(&(p->push),&tmp);
  Push(&(p->out),tmp);
 }
 Pop(&(p->out),rval);
 while(p->out.next!=NULL)
 {
  Pop(&(p->out),&tmp);
  Push(&(p->push),tmp);
 }
 return true;
}