用栈模拟实现队列

实现方法

使用两个栈，一个用来插入数据(StackPush)另一个用来删除数据(StackPop)。这样，当我们插入数据时，直接向StackPush尾插数据，当我们要删除数据时，如果StackPop为空，先将StackPush的数据放到StackPop，再将StackPop的数据尾删，如果StackPop不为空，直接尾删即可。

操作结果与队列相同

实现代码

栈实现队列的c语言代码要包含对应栈的代码，栈的结构与实现，可供参考。

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int StackDateType;

typedef struct Stack {
    StackDateType* data;
    int top;
    int capacity;
}Stack;

//栈的函数
void StackInit(Stack* p) {
    assert(p);
    p->data = (StackDateType*)malloc(sizeof(StackDateType) * 4);
    if (p->data == NULL) {
        perror("malloc fail");
        return;
    }
    p->capacity = 4;
    p->top = 0;
}

void StackDestory(Stack* p) {
    assert(p);
    free(p->data);
    p->data = NULL;
}

void StackPush(Stack* p, StackDateType x) {
    assert(p);
    //判断是否为满
    if (p->capacity == p->top) {
        p->data = (StackDateType*)realloc(p->data, sizeof(StackDateType) * p->capacity * 2);
        if (p->data == NULL) {
            perror("realloc fail");
            return;
        }
        p->capacity *= 2;
    }
    p->data[p->top] = x;
    p->top++;
}

bool StackEmpty(Stack* p) {
    assert(p);
    return p->top == 0;
}

void StackPop(Stack* p) {
    assert(p);
    //判断是否为空
    assert(!StackEmpty(p));
    p->top--;
}

StackDateType StackTop(Stack* p) {
    assert(p);
    assert(!StackEmpty(p));
    return p->data[p->top - 1];
}

//模拟实现队列的函数
struct{
    Stack spush;
    Stack spop;
}MyQueue;

MyQueue* myQueueCreate(){
    MYQueue* ret = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&ret->Spush);
    StackInit(&ret->Spop);
    return ret;
}

void myQueuePush(MyQueue* obj, int x){
    StackPush(&obj->spush, x);
}

bool myQueueEmpty(MyQueue* obj){
    return StackEmpty(&obj->spush)&&StackEmpty(&obj->spop);
}

int myQueuePop(MyQueue* obj){
    assert(!myQueueEmpty(obj));
    //pop栈为空，从push栈取数据
    if(StackEmpty(&obj->spop)){
        while(!StackEmpty(&obj->spush)){
            StackPush(&obj->spop,StackTop(&obj->spush);
            StackPop(&obj->spush);
        }
    }
    int ret = StackTop(&obj->spop);
    StackPop(&obj->spop);
    return ret;
}

//返回队列尾部元素
int myQueuePeek(MyQueue* obj){
    assert(!myQueueEmpty(obj));
    //pop栈为空，从push栈取数据
    if(StackEmpty(&obj->spop)){
        while(!StackEmpty(&obj->spush)){
            StackPush(&obj->spop,StackTop(&obj->spush);
            StackPop(&obj->spush);
        }
    }
    return StackTop(&obj->spop);

void myQueueFree(MyQueue* obj){
    free(&obj->spush);
    free(&obj->spop);
    free(obj);
}