栈是不是栈，队列也不是队列---队列实现栈，栈实现队列

一、队列实现栈

1.实现思路

假设需要用栈存储1，2，3，4，则出栈顺序是4，3，2，1.
用队列存储1，2，3，4直接出队是1，2，3，4.如果队列和栈中都只有一个数字，那么入栈出栈和入队出队就是一样的。
我们使用两个队列来实现栈，队列q1和队列q2，起始两个队列都为空，我们将n个元素存入任何一个都可以，我们存入q1并且以1，2，3，4的方式一次入队。

现在我们将前n-1个数字出队并依次存入q2中，此时q1中只剩下1个元素并且是刚刚入队时的最后一个元素，把这个元素直接出队，此时出队以后q1为空。

在将q2中剩下的n-1个元素一次入队到q1中，此时q2中只剩下一个元素时，出队。

每次都将n-1个元素入队到另一个为空的队列中，剩下的一个出队，直到两个元素都为空时，出队的顺序就是使用栈时出栈的顺序。

2.实现代码

以下为队列实现栈做铺垫，先完成队列的实现
具体解释可以参考上一篇文章“栈和队列”

（1）创建一个队列实现的栈

因为我们需要两个队列来完成栈的实现

typedef struct 
{
    Queue q1;
    Queue q2;
} MyStack;

/** Initialize your data structure here. */

MyStack* myStackCreate() 
{
    MyStack* pst=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);
    return pst;
}

（2）将一个元素压入栈中

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) 
{
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

（3）删除栈顶元素并返回

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) 
{
    Queue* pEmpty=&obj->q1;
    Queue* pNonEmpty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        pEmpty=&obj->q2;
        pNonEmpty=&obj->q1;
    }
    while(QueueSize(pNonEmpty)>1)
    {
        QueuePush(pEmpty,QueueFront(pNonEmpty));
        QueuePop(pNonEmpty);
    }
    int front=QueueFront(pNonEmpty);
    QueuePop(pNonEmpty);
    return front;
}

（4）取栈顶元素

/** Get the top element. */
int myStackTop(MyStack* obj) 
{
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

（5）判断栈是否为空

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) 
{
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

（6）销毁栈

void myStackFree(MyStack* obj) 
{
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

二、栈实现队列

1.实现思路

假设需要用队列存储1，2，3，4，则出队列顺序是1，2，3，4.我们采用两个栈来实现，刚开始两个栈都是空的，先将元素存入到一个栈中。

再将栈中元素以4，3，2，1的顺序出栈全部一次存入另一个栈中，此时再将栈中元素依次出栈就是，1，2，3，4.

2.实现代码

以下为队列实现栈做铺垫，先完成栈的实现
具体解释可以参考上一篇文章“栈和队列”

（1）创建一个栈实现的队列

因为我们需要两个栈来完成栈的实现

typedef struct 
{
    Stack pushST;
    Stack popST;
} MyQueue;

/** Initialize your data structure here. */

MyQueue* myQueueCreate() 
{
    MyQueue* q=(MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->pushST);
    StackInit(&q->popST);
    return q;
}

（2）入栈一个元素

/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) 
{
    StackPush(&obj->pushST,x);
}

（3）取队头元素

/** Get the front element. */
int myQueuePeek(MyQueue* obj) 
{
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST)；
        }
    }
    return StackTop(&obj->popST);
}

（4）删除队头元素并返回

/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) 
{
    int top=myQueuePeek(&obj);
    StackPop(&obj->popST);
    return top;
}

（5）判断队列是否为空

/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) 
{
    return StackEmpty(&obj->pushST)&&StackEmpty(&obj->popST);
}

（6）销毁队列

void myQueueFree(MyQueue* obj) 
{
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    free(obj);
}