【LeetCode】用栈实现队列（C语言） | 动图演示，超详细哦~

题目难度：《简单》

（1）题目描述

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

• void push(int x) 将元素 x 推到队列的末尾
• int pop() 从队列的开头移除并返回元素
• int peek() 返回队列开头的元素
• boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

• 你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
• 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例：

输入：
[ “MyQueue” , “push” , “push” , “peek” , “pop” , “empty” ] //调用函数接口
[ [ ] , [1] , [2] , [ ] , [ ] , [ ] ]
输出：
[null , null , null , 1 , 1 , false]

LeetCode链接：232. 用栈实现队列

---

（2）解题思路

• 创建两个栈 S1 和 S2，相互倒数据，实现队列（先进先出）
• S1 为输入栈，用于 push 操作；S2 为输出栈，用于 pop 和 peek 操作。
• 入数据，向 S1 入。
• 出数据，判断一下 S2 是否为空，
• （1）如果 S2 为空，先将输入栈 S1 中的的全部数据依次弹出并压入到输出栈 S2 中后，再 Pop 掉 S2 的栈顶数据。
• （2）如果 S2 不为空，那就直接 Pop 掉 S2 的栈顶数据。
• 动图演示

• 代码如下

首先实现一个栈（博主这里实现的是可动态增长的顺序栈），之前讲过栈的实现，这里就直接贴代码了

参考文章：【数据结构入门】栈（Stack）的实现（定义、销毁、入栈、出栈等） | 图解数据结构，超详细哦~

typedef int ElemDataType;
//定义可以动态增长的顺序栈
typedef struct Stack
{
    ElemDataType* a;
    int top;
    int capacity;
}Stack;

//初始化栈
void StackInit(Stack* ps)
{
    assert(ps);
    ps->a = NULL;
    ps->top = -1;
    ps->capacity = 0;
}

//销毁栈
void StackDestroy(Stack* ps)
{
    assert(ps);
    if(ps->a)
    {
        free(ps->a);
    }
    ps->a = NULL;
    ps->top = -1;
    ps->capacity = 0;
}

//入栈
void StackPush(Stack* ps, char x)
{
    assert(ps);
    if(ps->top == ps->capacity - 1)  //检查栈的容量是否已满
    {
        //扩容
        int newcapacity = (ps->capacity == 0) ? 4 : 2 * (ps->capacity);
        ElemDataType* temp = realloc(ps->a, newcapacity * sizeof(ElemDataType));
        if(temp == NULL)
        {
            perror("realloc");
            exit(-1);
        }
        ps->a = temp;
        ps->capacity = newcapacity;  //更新容量
    }
    ps->top++;
    ps->a[ps->top] = x;
}

//出栈
void StackPop(Stack* ps)
{
    assert(ps);
    assert(ps->top != -1);  //栈不能为空
    ps->top--;
}

//获取栈顶元素
ElemDataType StackTop(Stack* ps)
{
    assert(ps);
    return ps->a[ps->top];
}

//获取栈的元素个数
int StackSize(Stack* ps)
{
    assert(ps);
    return ps->top + 1;
}

//检查栈是否为空
bool StackEmpty(Stack* ps)
{
    assert(ps);
    return ps->top == -1;
}

核心代码（用两个栈实现先入先出队列）

typedef struct {
    Stack S1;
    Stack S2;
} MyQueue;

/** 初始化队列 */
MyQueue* myQueueCreate() {
    //创建两个栈
    MyQueue* pst = (MyQueue*)malloc(sizeof(MyQueue));
    if(pst == NULL)  //检查空间是否申请成功
    {
        perror("malloc");
        exit(-1);
    }
    //初始化两个栈
    StackInit(&pst->S1);
    StackInit(&pst->S2);
    
    return pst;
}

/** 入队 */
void myQueuePush(MyQueue* obj, int x) {
    assert(obj);

    StackPush(&obj->S1, x);  //入数据，向S1入
}

/** 出队 */
int myQueuePop(MyQueue* obj) {
    assert(obj);

    //出数据
    if(StackEmpty(&obj->S2))  //如果S2为空，先将S1中的全部数据导入到S2中
    {
        while(StackSize(&obj->S1) != 0)
        {
            StackPush(&obj->S2, StackTop(&obj->S1));
            StackPop(&obj->S1);
        }
    }
    //Pop掉S2的栈顶元素
    int temp = StackTop(&obj->S2);
    StackPop(&obj->S2);  //栈顶元素出栈
    return temp;
}

/** 获取队头元素 */
int myQueuePeek(MyQueue* obj) {
    assert(obj);

    if(StackEmpty(&obj->S2))  //如果S2为空，先将S1中的全部数据导入到S2中
    {
        while(StackSize(&obj->S1) != 0)
        {
            StackPush(&obj->S2, StackTop(&obj->S1));
            StackPop(&obj->S1);
        } 
    }
    return StackTop(&obj->S2);  //返回S2的栈顶元素
}

/** 检查队列是否为空，若为空返回true，否则返回false */
bool myQueueEmpty(MyQueue* obj) {
    assert(obj);
    return StackEmpty(&obj->S1) && StackEmpty(&obj->S2);
}

/** x */
void myQueueFree(MyQueue* obj) {
    assert(obj);

    StackDestroy(&obj->S1);  //释放栈S1
    StackDestroy(&obj->S2);  //释放栈S2
    
    free(obj);  //释放动态开辟的空间
}

---

大家快去动手练习一下吧！