用栈实现队列

栈的定义：

typedef int STDataType;
typedef struct Stack
{
    STDataType* arr;
    int top;        // 栈顶
    int capacity;  // 容量 
}ST;
// 初始化栈 
void STInit(ST* ps);
// 入栈 
void STPush(ST* ps, STDataType x);
// 出栈 
void STPop(ST* ps);
// 获取栈顶元素 
STDataType STTop(ST* ps);
// 获取栈中有效元素个数 
int STSize(ST* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool STEmpty(ST* ps);
// 销毁栈 
void STDestroy(ST* ps);


void STInit(ST* ps) {
    assert(ps);
    ps->top = 0;
    ps->capacity = 2;
    ps->arr = (STDataType*)malloc(ps->capacity * sizeof(STDataType));
    if (ps->arr == NULL) {
        perror("malloc is fail!\n");
        exit(-1);
    }
}


void STDestroy(ST* ps) {
    assert(ps);


    free(ps->arr);
    ps->arr = NULL;
    ps->top = 0;
    ps->capacity = 0;
}


void STPush(ST* ps, STDataType x) {
    assert(ps);
    //位置不够就扩容
    if (ps->top == ps->capacity) {
        ps->capacity *= 2;
        STDataType* tmp = (STDataType*)realloc(ps->arr, sizeof(STDataType) * ps->capacity);
        if (tmp == NULL) {
            perror("realloc is fail!\n");
            exit(-1);
        }
        ps->arr = tmp;
        printf("capacity expand is success!\n");
    }
    ps->arr[ps->top] = x;
    ps->top++;
}


STDataType STTop(ST* ps) {
    assert(ps);
    assert(!STEmpty(ps));
    //top为栈顶元素的下一个
    return ps->arr[ps->top - 1];
}


void STPop(ST* ps) {
    assert(ps);
    if (!STEmpty(ps)) {
        ps->top--;
    }
    else {
        printf("栈已空！\n");
    }
}


bool STEmpty(ST* ps) {
    assert(ps);
    //if (ps->top == 0) {
    //  return true;
    //}
    //else {
    //  return false;
    //}


    return ps->top == 0;
}


int STSize(ST* ps) {
    assert(ps);
    return ps->top;
}

思路：

设置两个队列，一个为spush一个为spop
入队：往spush中插入数据
出队：从spop中出数据，若spop中没有数据则把当前spush中的所有数据导入spop
返回队头元素：若spop中没有数据则先把当前spush中的所有数据导入spop再获取spop中的栈顶元素
判空：若都为空则为空

typedef struct {
    ST spush;
    ST spop;
} MyQueue;



MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&obj->spush);
    STInit(&obj->spop);
    return obj;
}
void myQueuePush(MyQueue* obj, int x) {
    //往spush中插入数据
    STPush(&obj->spush,x);
}


int myQueuePop(MyQueue* obj) {
    //如果spop中没有数据，导入数据
    if(STEmpty(&obj->spop)){
        while(!STEmpty(&obj->spush)){
            //spush的栈顶元素导入spop中
            STPush(&obj->spop,STTop(&obj->spush));
            //spush栈顶元素出栈
            STPop(&obj->spush);
        }
    }
    //记录spop栈顶元素，spop栈顶元素出栈
    int top = STTop(&obj->spop);
    STPop(&obj->spop);
    return top;
}


int myQueuePeek(MyQueue* obj) {
    //如果spop中没有数据，导入数据
    if(STEmpty(&obj->spop)){
        while(!STEmpty(&obj->spush)){
            //spush的栈顶元素导入spop中
            STPush(&obj->spop,STTop(&obj->spush));
            //spush栈顶元素出栈
            STPop(&obj->spush);
        }
    }
    return STTop(&obj->spop);;
}


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


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