使用栈实现队列

目录

• 一.栈实现队列概念
• 二.入队
• 三.出队
• 四.获取队首元素
• 五.判空
• 六.代码

一.栈实现队列概念

需要俩个栈，入队栈s1，出队栈s2

二.入队

直接将元素压入s1

三.出队

如果s2为空则将s1元素全部压入s2。最后弹出s2栈顶元素返回

四.获取队首元素

如果s2为空则将s1元素全部压入s2。获取s2栈顶元素返回。

五.判空

如果s1，s2全为空则返回true，否则返回false

六.代码

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

#define eleType int

typedef struct {
    eleType* elements;
    size_t size;         // 栈的当前大小
    size_t capacity;     // 栈的容量
} Stack;

// 初始化栈
void StackCreate(Stack* stk) {
    stk->elements = (eleType *)malloc(sizeof(eleType) * 8);
    if (stk->elements == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    stk->size = 0;
    stk->capacity = 8; // 初始栈容量为8
}

// 销毁栈
void StackDestroy(Stack* stk) {
    free(stk->elements);
    stk->elements = NULL;
    stk->size = 0;
    stk->capacity = 0;
}

// 扩容
void StackResize(Stack* stk) {
    eleType* newelements = (eleType*)realloc(stk->elements, sizeof(eleType) * stk->capacity * 2); // 重新分配空间
    if (newelements == NULL) {
        printf("内存重新分配失败\n");
        exit(1);
    }
    stk->capacity *= 2; // 为原来的两倍
    stk->elements = newelements;
}

// 压入元素
void StackPush(Stack* stk, eleType element) {
    if (stk->capacity == stk->size) { // 如果满栈扩容
        StackResize(stk);
    }
    stk->elements[stk->size++] = element;
}

// 弹出元素
eleType StackPop(Stack* stk) {
    if (stk->size == 0) {
        printf("栈元素不够\n");
        exit(1);
    }
    return stk->elements[--stk->size]; // 弹出并且栈大小减一
}

// 栈顶元素
eleType StackTop(Stack* stk) {
    if (stk->size == 0) {
        printf("空栈\n");
        exit(1);
    }
    return stk->elements[stk->size - 1]; // 获得栈顶元素
}

// 获取栈的大小
size_t StackGetsize(Stack* stk) {
    return stk->size;
}

typedef struct {
    Stack q1;
    Stack q2;
} Mystack;

// 创建栈
Mystack* MystackCreate() {
    Mystack* obj = (Mystack*)malloc(sizeof(Mystack));
    StackCreate(&obj->q1);
    StackCreate(&obj->q2);
    return obj;
}

// 销毁栈
void MystackFree(Mystack* obj) {
    StackDestroy(&obj->q1);
    StackDestroy(&obj->q2);
    free(obj);
}

// 入队
void MystackPush(Mystack* obj, int x) {
    StackPush(&obj->q1, x);
}

// 出队
int MystackPop(Mystack* obj) {
    if (StackGetsize(&obj->q2) == 0) {
        while (StackGetsize(&obj->q1)) {
            StackPush(&obj->q2, StackPop(&obj->q1));
        }
    }
    return StackPop(&obj->q2);
}

// 获取队首元素
int MystackTop(Mystack* obj) {
    if (StackGetsize(&obj->q2) == 0) {
        while (StackGetsize(&obj->q1)) {
            StackPush(&obj->q2, StackPop(&obj->q1));
        }
    }
    return StackTop(&obj->q2);
}

// 判断队列是否为空
bool MystackEmpty(Mystack* obj) {
    return StackGetsize(&obj->q1) + StackGetsize(&obj->q2) == 0;
}

int main() {
    Mystack* q = MystackCreate();
    MystackPush(q, 10);
    MystackPush(q, 20);
    MystackPush(q, 30);
    while (!MystackEmpty(q)) {
        printf("top is %d\n", MystackTop(q));
        printf("pop is %d\n", MystackPop(q));
    }
    MystackFree(q);
    return 0;
}