C语言编程实战：每日一题：用栈实现队列

say_fall2025-12-12 11:15

欢迎来到 s a y − f a l l 的文章 欢迎来到say-fall的文章 欢迎来到say−fall的文章

🌈 say-fall：个人主页 🚀 专栏：《手把手教你学会C++》 | 《C语言从零开始到精通》 | 《数据结构与算法》 | 《小游戏与项目》 💪 格言：做好你自己，才能吸引更多人，与他们共赢，这才是最好的成长方式。

文章目录

  • 题目：用栈实现队列
    • [1. 思路解析（初）：](#1. 思路解析（初）：)
    • [2. 代码(初)：](#2. 代码(初)：)
    • [3. 思路解析（优化）](#3. 思路解析（优化）)
    • [4. 代码（优化）](#4. 代码（优化）)

题目：用栈实现队列

1. 思路解析（初）：

最初我采用了一种相对复杂的实现方式。核心思路是：利用栈结构实现队列功能时，将新元素存入主栈后，通过转移操作保持元素顺序。
具体操作流程：

  1. 首次存入元素：

    将元素从主栈转移到辅助栈：

    使用时直接从辅助栈取出，确保主栈始终保持为空
  2. 后续存入元素：
    先将新元素存入主栈：

    再将所有元素转移到辅助栈：

    这样每次执行删除或获取操作时，直接从辅助栈处理即可

2. 代码(初)：

初始写法

c 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef int STDatatype;
typedef struct Stack
{
    STDatatype* ptr;
    int top;
    int capacity;
}Stack;

//初始化与销毁
void StackInit(Stack* ps);
void StackDestroy(Stack* ps);

//入栈与出栈
void StackPush(Stack* ps, STDatatype x);
void StackPop(Stack* ps);

//查看顶端元素
STDatatype StackTop(Stack* ps);

//判空
bool StackEmpty(Stack* ps);

//有效元素个数
int StackSize(Stack* ps);

//初始化与销毁
void StackInit(Stack* ps)
{
    assert(ps);

    ps->ptr = NULL;
    ps->capacity = 0;
    //指向栈顶的下一个位置
    ps->top = 0;
}
void StackDestroy(Stack* ps)
{
    assert(ps);

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

//入栈与出栈
void StackPush(Stack* ps, STDatatype x)
{
    assert(ps);

    if (ps->top == ps->capacity)
    {
        int newcapacity = ps->capacity == 0 ? 4 : (2 * ps->capacity);
        STDatatype* tmp = (STDatatype*)realloc(ps->ptr, newcapacity * sizeof(STDatatype));
        if (tmp == NULL)
        {
            perror("realloc");
            return;
        }
        ps->ptr = tmp;
        ps->capacity = newcapacity;
    }
    ps->ptr[ps->top] = x;
    ps->top++;
}
void StackPop(Stack* ps)
{
    assert(ps);
    assert(ps->top > 0);

    ps->top--;
}


//查看顶端元素
STDatatype StackTop(Stack* ps)
{
    assert(ps);
    assert(ps->top > 0);

    return ps->ptr[ps->top - 1];
}

//判空
bool StackEmpty(Stack* ps)
{
    assert(ps);

    return ps->top == 0;
}

//有效元素个数
int StackSize(Stack* ps)
{
    assert(ps);

    return ps->top;
}



typedef struct {
    Stack st1;
    Stack st2;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));

    StackInit(&(obj->st1));
    StackInit(&(obj->st2));
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
     //如果都没有元素，随便插入
     if(StackEmpty(&obj->st1) && StackEmpty(&obj->st2))
     {
         StackPush(&obj->st1,x);
     }
    //如果有元素，先把元素挪到另一个栈中；
    else
    {
        Stack* empty = &obj->st1;
    	Stack* nonempty = &obj->st2;
    	if (!StackEmpty(empty))
    	{
        	empty = &obj->st2;
        	nonempty = &obj->st1;
    	}

    while (!StackEmpty(nonempty))
    {
        StackPush(empty, StackTop(nonempty));
        StackPop(nonempty);
    }
    StackPush(empty, x);
    while (!StackEmpty(empty))
    {
        StackPush(nonempty, StackTop(empty));
        StackPop(empty);
    }
    }
}

int myQueuePop(MyQueue* obj) {
    Stack* empty = &obj->st1;
    Stack* nonempty = &obj->st2;
    if (!StackEmpty(empty))
    {
        empty = &obj->st2;
        nonempty = &obj->st1;
    }
    int top = StackTop(nonempty);
    StackPop(nonempty);
    return top;
}

int myQueuePeek(MyQueue* obj) {
    Stack* empty = &obj->st1;
    Stack* nonempty = &obj->st2;
    if (!StackEmpty(empty))
    {
        empty = &obj->st2;
        nonempty = &obj->st1;
    }
    return StackTop(nonempty);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->st1) && StackEmpty(&obj->st2);
}

void myQueueFree(MyQueue* obj) {
	StackDestroy(&obj->st1); 
	StackDestroy(&obj->st2);
    free(obj);
    obj = NULL;
}

3. 思路解析（优化）

通过设计输入栈和输出栈的双栈结构实现队列功能：

  • 所有入队操作直接压入输入栈
  • 出队操作从输出栈弹出元素
  • 当输出栈为空时，将输入栈所有元素依次弹出并压入输出栈

这种方法使入队和出队操作的时间复杂度均为O(1)，相比原来的实现更高效。

4. 代码（优化）

c 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int STDatatype;
typedef struct Stack {
    STDatatype* ptr;
    int top;
    int capacity;
} Stack;

// 栈基本操作
void StackInit(Stack* ps);
void StackDestroy(Stack* ps);
void StackPush(Stack* ps, STDatatype x);
void StackPop(Stack* ps);
STDatatype StackTop(Stack* ps);
bool StackEmpty(Stack* ps);
int StackSize(Stack* ps);

void StackInit(Stack* ps) {
    assert(ps);
    ps->ptr = NULL;
    ps->capacity = 0;
    ps->top = 0;  // 指向栈顶的下一个位置
}

void StackDestroy(Stack* ps) {
    assert(ps);
    free(ps->ptr);
    ps->ptr = NULL;
    ps->capacity = ps->top = 0;
}

void StackPush(Stack* ps, STDatatype x) {
    assert(ps);
    if (ps->top == ps->capacity) {
        int newcapacity = ps->capacity == 0 ? 4 : (2 * ps->capacity);
        STDatatype* tmp = (STDatatype*)realloc(ps->ptr, newcapacity * sizeof(STDatatype));
        if (tmp == NULL) {
            perror("realloc");
            return;
        }
        ps->ptr = tmp;
        ps->capacity = newcapacity;
    }
    ps->ptr[ps->top++] = x;
}

void StackPop(Stack* ps) {
    assert(ps);
    assert(ps->top > 0);
    ps->top--;
}

STDatatype StackTop(Stack* ps) {
    assert(ps);
    assert(ps->top > 0);
    return ps->ptr[ps->top - 1];
}

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

int StackSize(Stack* ps) {
    assert(ps);
    return ps->top;
}

// 队列实现
typedef struct {
    Stack InStack;  // 输入栈
    Stack OutStack; // 输出栈
} MyQueue;

// 当输出栈为空时，将输入栈元素转移到输出栈
void transferElements(MyQueue* obj) {
    assert(obj);
    if (StackEmpty(&obj->OutStack)) {
        while (!StackEmpty(&obj->InStack)) {
            StackPush(&obj->OutStack, StackTop(&obj->InStack));
            StackPop(&obj->InStack);
        }
    }
}

MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&(obj->InStack));
    StackInit(&(obj->OutStack));
    return obj;
}

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

int myQueuePop(MyQueue* obj) {
    assert(obj);
    transferElements(obj);
    int top = StackTop(&obj->OutStack);
    StackPop(&obj->OutStack);
    return top;
}

int myQueuePeek(MyQueue* obj) {
    assert(obj);
    transferElements(obj);
    return StackTop(&obj->OutStack);
}

bool myQueueEmpty(MyQueue* obj) {
    assert(obj);
    return StackEmpty(&obj->InStack) && StackEmpty(&obj->OutStack);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->InStack);
    StackDestroy(&obj->OutStack);
    free(obj);
    obj = NULL;
}
  • 本节完...
相关推荐
魔力女仆9 小时前
分享一个 JS 鼠标跟随贪吃蛇背景库
开发语言·javascript·计算机外设
2401_8949155310 小时前
GEO 搜索优化完整源码从零部署：环境配置、集群搭建全流程
开发语言·python·tcp/ip·算法·unity
麻瓜老宋11 小时前
AI开发C语言应用按步走，表达式计算器calc的第二十二步，分号赋值链式修复、TOKEN_ASSIGN
c语言·开发语言·atomcode
颜x小13 小时前
[C#] C++与c#语法对比
开发语言·c++·c#
weixin_4236521313 小时前
C#使用JObject
开发语言·c#
国科安芯13 小时前
FreeRTOS RISC-V 浮点上下文切换移植：在 IAR 工程中完整保存 FPU 寄存器
java·开发语言·单片机·嵌入式硬件·算法·系统架构·risc-v
霸道流氓气质14 小时前
Java中集成Smile 技术教程：从入门到工程实践
java·开发语言
BerrySen17815 小时前
迈向 Next-Gen Java：企业级高并发架构演进与大模型 Agent 落地深度实战
java·开发语言·架构
SilentSlot15 小时前
【C/C++】手写 DPDK 协议栈（十一）：基于 PPS、SYN 比例和源 IP 熵的 DDoS 检测
c语言·c++·tcp/ip
Nebula_g15 小时前
Java实现本地Socket通信（三）
java·开发语言·学习·socket·可视化
热门推荐
01如何新建文件夹？ 电脑新建文件夹的4种方法02GitHub 镜像站点032026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片04国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）05AI科技热点日报 | 2026年07月01日06AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路072026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？08微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新09幻兽帕鲁 - 服务器管理员权限与 GM 命令完全指南10Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费