队列和栈的相互实现

队列实现栈

可以考虑用两个队列实现一个栈，每次总保持一个队列为空。

此时的入栈操作即为入队操作。 出栈操作即飞空队列的队尾元素出栈，此时要把队列中其他元素移动到另一个空栈中，然后出最后一个元素。

利用队列替代栈的节点：

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

主体实现：

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

//创建栈
MyStack* myStackCreate() {
    MyStack* pst=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);
    return pst;
}
//插入元素
void myStackPush(MyStack* obj, int x) {
    if(QueueEmpty(&obj->q1)!=0){
        QueuePush(&obj->q1,x);
    }else{
        QueuePush(&obj->q2,x);
    }
}
//删除元素
int myStackPop(MyStack* obj) {
    Queue* pEmpty=&obj->q1;
    Queue* pNonEmpty=obj->q2;
    if(QueueEmpty(&obj->q1)!=0){
        pEmpty=&obj->q2;
        pNonEmpty=&obj->q1;
    }
    while(QueueSize(pNonEmpty)>1){
        QueuePush(pEmpty,QueueFront(pNonEmpty));
        QueuePop(pNonEmpty);
    }
    int top=QueueFront(pNonEmpty);
    QueuePop(pNonEmpty);
    return top;
}
//获取对头元素
int myStackTop(MyStack* obj) {
    Queue* pEmpty=&obj->q1;
    Queue* pNonEmpty=&obj->q2;
    if(QueueEmpty(&obj->q1)!=0){
        pEmpty=&obj->q2;
        pNonEmpty=&obj->q1;
    }
    return QueueBack(pNonEmpty);
}

bool myStackEmpty(MyStack* obj) {
    return !(QueueEmpty(&obj->q1)|QueueEmpty(&obj->q2));
}

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

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

栈实现队列

同上可以用两个栈实现。一个栈进行入队一个栈进行出队

出队操作，当出队的栈不是空时，直接出栈，如果为空则需要把入对的栈元素全都转移到出队的栈，然后进行出栈操作。

利用栈代替队列的节点：

typedef struct {
    //入队栈
    Stack pushST;
    //出队栈
    Stack popST;
} MyQueue;

主体实现：

//创建栈
MyQueue* myQueueCreate() {
    MyQueue* pqueue=(MyQueue*)mallco(sizeof(MyQueue));
    StackInit(&pqueue->pushST,maxSize);
    StackInit(&pqueue->popST,maxSize);
    return pqueue;
}
//入栈
void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->pushST,x);
}
//出栈
int myQueuePop(MyQueue* obj) {
    if(StackEmpty(&obj->popST)==0){
        while(StackEmpty(&obj->popST)!=0){
            StackTop(&obj->popST,S (&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    int front=StackTop(&obj->popST);
    StackPop(&obj->popST);
    return front;
}
//获取栈顶元素
int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->popST)==0){
        while(StackEmpty(&obj->pushST)!=0){
            StackPush(obj->popST，StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    return StackTop(&obj->popST);
}
//检测
bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushST)==0 && StackEmpty(&obj->popST)==0;
}

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

在上代码中引用的栈操作与队列操作均在下贴中有体现：
队列操作
栈操作