数据结构之栈与队列

原创 于 2026-08-21 16:07:03 发布 · 265 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测

一、栈

（一）栈的结构

用数组作为栈的结构存储数据，使用结构体用于约束数组，在结构体中定义两个指针指向栈的栈顶top和栈底base，要求只能从栈顶入栈和出栈（只能从栈的一端操作）；定义一个整型变量stacksize用于表示当前栈的容量（可以存放数据的最大数量）。

typedef int SElemType;
typedef int Status;
typedef struct{
    SElemType *base;//栈底
    SElemType *top;//栈顶
    int stacksize;//栈容量
}SqStack;

（二）初始化栈

Status InitSqStack(SqStack *S)，传入参数为结构体指针（需要为结构体申请空间，所以需要传指针），在堆区动态分配一块连续内存作为栈的存储空间，并让栈顶指针和栈底指针都指向该空间的起始位置，表示当前栈为空。

//初始化
Status InitSqStack(SqStack *S){
    //申请定长空间
    S->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S->base) exit(OVERFLOW);  //申请失败
    S->top=S->base;
    S->stacksize=STACK_INIT_SIZE;  //更新容量
    return OK;
}

（三）入栈

Status Push(SqStack *S,SElemType e)，将数据e入栈：先判断栈是否满了，如果是满栈则需要使用realloc对其扩容。realloc扩容如果后面有足够的空间可以实现原地扩展（直接在后面扩容），如果后面空间不够则需要另外开辟一段更大的空间，逐字节拷贝过去并自动释放旧内存。所以扩容后需要更新栈顶指针与容量大小。最后将入栈元素赋值给栈顶指针，赋值后更新栈顶指针（指向入站元素的下一个位置）。

//入栈
Status Push(SqStack *S,SElemType e){
    if(S->top - S->base ==S->stacksize){//栈满扩容
        S->base=(SElemType *)realloc(S->base,(S->stacksize + STACKINCREMENT)*sizeof(SElemType));
        if(!S->base) exit(OVERFLOW);
        //扩容可能会另外申请空间，地址会改变，所以需要更新栈顶指针
        S->top=S->base + S->stacksize;//需要更新栈顶指针
        S->stacksize+=STACKINCREMENT;//扩容后更新容量
    }
    *S->top++=e;//先赋值后移动top指针
    return OK;
}

（四）出栈

Status Pop(SqStack *S,SElemType *e)，出栈并将出栈数据存入e中：判断是否为空栈，非空则先将栈顶指针移动到栈顶元素，再将其存入e。

//出栈
Status Pop(SqStack *S,SElemType *e){
    if(S->base == S->top) return ERROR; //空栈无元素
    e=*--S->top; //先将栈顶指针移动到栈顶元素，再将其赋给e
    return OK;
}

（五）查看栈顶指针

Status GetTop(SqStack *S,SElemType *e)，查看栈顶指针并存入e：先判断是否为空栈，若非空则将栈顶指针的前一个元素（栈顶元素）的数据赋给e。

//查看栈顶元素
Status GetTop(SqStack *S,SElemType *e){
    if(S->base == S->top) return ERROR; //空栈无元素
    e=*(S->top -1); //先将栈顶指针的前一个元素赋给e（不改变栈顶指针）
    return OK;
}

（六）判空

比较栈底指针和栈顶指针是否指向同一位置，是则为空栈，否则非空。

//判空
Status isEmpty(SqStack *S){
    return  S->base == S->top;
}

（七）清空

移动栈顶指针，使其和栈底指针指向同一位置（不需要处理数据），则表示已清空。

//清空
void ClearLine(SqStack *S){
    while(S->top != S->base) --S->top;
}

完整测试代码：

#include <stdio.h>
#include <stdlib.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define OK 1
#define ERROR 0
#define OVERFLOW -1
typedef int SElemType;
typedef int Status;
typedef struct{
    SElemType *base;//栈底
    SElemType *top;//栈顶
    int stacksize;//栈容量
}SqStack;

//初始化
Status InitSqStack(SqStack *S){
    //申请定长空间
    S->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S->base) exit(OVERFLOW);  //申请失败
    S->top=S->base;
    S->stacksize=STACK_INIT_SIZE;  //更新容量
    return OK;
}

//入栈
Status Push(SqStack *S,SElemType e){
    if(S->top - S->base ==S->stacksize){//栈满扩容
        S->base=(SElemType *)realloc(S->base,(S->stacksize + STACKINCREMENT)*sizeof(SElemType));
        if(!S->base) exit(OVERFLOW);
        //扩容可能会另外申请空间，地址会改变，所以需要更新栈顶指针
        S->top=S->base + S->stacksize;//需要更新栈顶指针
        S->stacksize+=STACKINCREMENT;//扩容后更新容量
    }
    *S->top++=e;//先赋值后移动top指针
    return OK;
}

//出栈
Status Pop(SqStack *S,SElemType *e){
    if(S->base == S->top) return ERROR; //空栈无元素
    *e=*--S->top; //先将栈顶指针移动到栈顶元素，再将其赋给e
    return OK;
}

//查看栈顶元素
Status GetTop(SqStack *S,SElemType *e){
    if(S->base == S->top) return ERROR; //空栈无元素
    *e=*(S->top -1); //先将栈顶指针的前一个元素赋给e（不改变栈顶指针）
    return OK;
}

//判空
Status isEmpty(SqStack *S){
    return  S->base == S->top;
}

//清空
void ClearLine(SqStack *S){
    while(S->top != S->base) --S->top;
}

int main(){
    SqStack S;
    int e=0;
    InitSqStack(&S);
    Push(&S,1);
    Push(&S,2);
    Push(&S,3);
    Push(&S,4);
    printf("依次入栈：");
    for(int i=0;S.base+i<S.top;i++){
        printf("%d ",*(S.base+i));
    }
    Pop(&S,&e);//出栈
    printf("\n出栈：%d\n",e);
    printf("出栈顺序：");
    for(int i=1;S.top-i>=S.base;i++){
        printf("%d ",*(S.top-i));
    }
    if(isEmpty(&S)) printf("\n栈空\n");
    else {
        printf("\n栈非空，需要清空\n");
        ClearLine(&S);
        if(isEmpty(&S)) printf("已清空！\n");
    }
}

二、队列

（一）队列的结构

循环队列，使用数组存储数据，使用结构体进行约束。结构体中有两个整型变量分别用于表示队头与队尾的下标，一个指针指向存储数据的数组首地址。

#define MAXSIZE 100
typedef int ElemType;
typedef int Status;
typedef struct{
    ElemType *base; //指针指向数组
    int front;//队头下标
    int rear;//队尾下标
}SqQueue;

（二）初始化

在堆区动态分配一块连续内存作为队列的存储空间，并将队头指针front和队尾指针rear都初始化为 0，表示这是一个空队列。

Status InitQueue(SqQueue *Q){
    Q->base=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));
    if(!Q->base) exit(OVERFLOW);
    Q->front=Q->rear=0;
    return OK;
}

（三）入队

先检查队列是否已满（检查队尾下标的下一个位置是否等于队头下标，使用取模运算%MAXSIZE实现指针的循环移动）。将新元素e存入队尾rear，此时rear的值为下一个空闲位置（即队尾）。将队尾下标rear加一，使用取模运算实现循环：当rear到达数组末尾时，自动回到数组开头，更新后的rear表示新的空闲位置的下标。

//入队
Status EnQueue(SqQueue *Q,ElemType e){
    if((Q->rear+1)%MAXSIZE == Q->front) return ERROR;//队满
    Q->base[Q->rear]=e;  //入队赋值
    Q->rear=(Q->rear+1)%MAXSIZE;  //更新队尾下标
    return OK;
}

（四）出队

先检查队列是否为空（检查队头下标是否等于队尾下标）。将队头指针front所指向的元素值取出并保存到e中。将队头下标front加一，使用取模运算%MAXSIZE实现循环：当front到达数组末尾时，自动回到数组开头，更新后的front表示新的队头位置。

//出队
Status DeQueue(SqQueue *Q,ElemType *e){
    if(Q->front == Q->rear) return ERROR;//队空
    *e=Q->base[Q->front];
    Q->front=(Q->front+1)%MAXSIZE;
    return OK;
}

（五）查看队首元素

先检查队列是否为空（检查队头下标是否等于队尾下标）。将队头指针front所指向的元素值取出并保存到e中。由于只是查看元素而不删除它，因此队头指针front保持不变，不需要移动。

//查看队首元素
Status GetFront(SqQueue *Q,ElemType *e){
    if(Q->front == Q->rear) return ERROR;//队空
    *e=Q->base[Q->front];
    return OK;
}

（六）判断队列是否为空

//判断队列是否为空
Status isEmpty(SqQueue Q){
    return Q.front==Q.rear;
}

顺序队列测试代码：

#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -1

//队列的基本操作
#define MAXSIZE 100
typedef int ElemType;
typedef int Status;
typedef struct{
    ElemType *base; //指针指向数组
    int front;//队头下标
    int rear;//队尾下标
}SqQueue;

//初始化
Status InitQueue(SqQueue *Q){
    Q->base=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));
    if(!Q->base) exit(OVERFLOW);
    Q->front=Q->rear=0;
    return OK;
}

//入队
Status EnQueue(SqQueue *Q,ElemType e){
    if((Q->rear+1)%MAXSIZE == Q->front) return ERROR;//队满
    Q->base[Q->rear]=e;  //入队赋值
    Q->rear=(Q->rear+1)%MAXSIZE;  //更新队尾下标
    return OK;
}

//出队
Status DeQueue(SqQueue *Q,ElemType *e){
    if(Q->front == Q->rear) return ERROR;//队空
    *e=Q->base[Q->front]; 
    Q->front=(Q->front+1)%MAXSIZE;
    return OK;
}

//查看队首元素
Status GetFront(SqQueue *Q,ElemType *e){
    if(Q->front == Q->rear) return ERROR;//队空
    *e=Q->base[Q->front];
    return OK;
}

//判断队列是否为空
Status isEmpty(SqQueue Q){
    return Q.front==Q.rear;
}

int main(){
    SqQueue Q;
    int e=0;
    InitQueue(&Q);
    EnQueue(&Q,1);
    EnQueue(&Q,2);
    EnQueue(&Q,3);
    printf("队列元素：");
    for(int i=0;i<Q.rear;i++){
        printf("%d ",Q.base[i]);
    }
    DeQueue(&Q,&e);
    printf("\n出队：%d",e);
    if(isEmpty(Q)) printf("\n队空\n");
    else {
        printf("\n队非空\n");
    }
    return 0;
}

链队列测试代码：

#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -1

//链表队列的基本操作
typedef int ElemType;
typedef int Status;
typedef struct QNode{  //链队列结点
    ElemType data;
    struct QNode *next;
}QNode,*QueuePtr;

typedef struct{  //结构
    QueuePtr front; //队头指针，指向头结点（无数据）
    QueuePtr rear;  //队尾指针，指向队尾结点（有数据）
}LinkQueue;

//初始化
Status InitQueue(LinkQueue *Q){
    Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
    if(!Q->front) exit(OVERFLOW);
    Q->front->next=NULL;
    return OK;
}

//入队
Status EnQueue(LinkQueue *Q,ElemType e){
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
    if(!p) exit(OVERFLOW);
    p->data=e;
    p->next=NULL;
    Q->rear->next=p;
    Q->rear=p;
}

//出队
Status DeQueue(LinkQueue *Q,ElemType *e){
    if(Q->front == Q->rear) return ERROR;//空队
    QueuePtr p=Q->front->next;//队头结点
    *e=p->data;
    Q->front->next=p->next;
    //如果需要删除的结点为队尾结点,Q->front->next=p->next=NULL
    if(p == Q->rear) Q->rear=Q->front;  //置空
    free(p);
    return OK;
}

//查看队首元素
Status GetFront(LinkQueue *Q,ElemType *e){
    if(Q->front == Q->rear) return ERROR;//空队
    *e=Q->front->next->data;
    return OK;
}

int main(){
    LinkQueue Q;
    int e=0;
    InitQueue(&Q);
    for (int i = 1; i <= 5; i++) {
        printf("入队: %d\n", i);
        EnQueue(&Q, i);
    }
    GetFront(&Q, &e);
    printf("队首元素: %d\n", e);
    for (int i = 0; i < 3; i++) {
        DeQueue(&Q, &e);
        printf("出队: %d\n", e);
    }
    return 0;
}

链队列与顺序队列有什么区别？各自的优缺点？

（1）链队列与顺序队列的本质区别在于存储方式：

顺序队列使用连续的内存空间（数组）存储元素，通过队头指针front和队尾指针rear的下标移动实现入队出队。

链队列则使用不连续的链表结点存储元素，通过front指针指向头结点、rear指针指向尾结点实现入队出队。

（2）顺序队列的优点是访问速度快（连续存储）、实现简单、无指针额外开销；缺点是队列容量固定（静态数组）或需要动态扩容（动态数组），且为了区分队空和队满通常需要牺牲一个存储单元，存在空间浪费。

（3）链队列的优点是容量动态增长，不会因队列满而溢出（除非内存耗尽），插入删除操作只需修改指针无需移动数据；缺点是每个结点需要额外的指针域存储空间，访问速度相对较慢（不连续存储），且频繁的malloc/free可能导致内存碎片。

标签
#数据结构 #算法
Liuqy-05
关注
中级软考（软件攻城狮）第3章知识点——数据结构与数据运算（线性结构+非线性结构）
睡不醒的每天
08-18 155
本文系统梳理了数据结构中的线性与非线性结构。线性部分详细介绍了线性表（顺序/链式存储及时间复杂度对比）、栈（后进先出特性及应用）、队列（循环队列与双端队列）以及串（空串与子串概念）。非线性部分涵盖数组、矩阵、广义表，重点解析了树结构（二叉树性质、存储方式及遍历方法），并深入讲解了最优二叉树（哈夫曼树）的构建原理与编码应用。全文通过图示对比和实例说明，清晰呈现了各类数据结构的特点、存储方式及典型应用场景。
R语言使用survminer包的ggcompetingrisks函数可视化竞争风险的累积事件曲线、使用可视化对象的mapping属性自定义修改、配置颜色分组及线条类型
data+scenario+science+insight
04-01 1359
R语言使用survminer包的ggcompetingrisks函数可视化竞争风险的累积事件曲线、使用可视化对象的mapping属性自定义修改、配置颜色分组及线条类型
数据结构与算法——栈和队列
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
全国行政区边界-KML格式
全国行政区边界，包含省、市、区（县）边界，KML格式，可直接导入奥维地图、GPS工具箱等。
[详解栈和队列]数据结构之栈与队列
Philosophy7的博客
05-12 4188
✅作者简介：大家好,我是Philosophy7？让我们一起共同进步吧！🏆 📃个人主页：Philosophy7的csdn博客 🔥系列专栏： 👑哲学语录: 承认自己的无知，乃是开启智慧的大门 💖如果觉得博主的文章还不错的话，请点赞👍+收藏⭐️+留言📝支持一下博>主哦🤞 文章目录栈和队列1.物理结构和逻辑结构2.什么是栈2.1栈的基本操作3.什么是队列队列的基本操作小结 栈和队列 1.物理结构和逻辑结构 再了解栈和队列之前，我们要先知道什么是逻辑结构和物理结构。 逻辑结构: 按照逻辑结构划分:数据结.
【数据结构】栈和队列
2301_81348661的博客
12-08 3754
然后，我们可以使用STTop取出栈(st)中的数据，进行对栈(s)的左右括号的匹配，如果匹配不成功，则返回false，直到栈(s)为空时，过程结束。若节点大于一个，那我们可以创建一个QNode*的next节点指向队头指向的下一个节点，然后再将队头的节点free，再重新将队头的节点改为next指针指向的新节点。首先，我们来了解一种新的数据结构——栈。将数据导入栈中，首先，将空间进行扩容（防止空间不足引起的越界访问）,并将扩容后的空间传给数组a，然后，再于新空间进行导入数据的操作，结尾记得改变新栈的个数。
【数据结构】栈与队列
做梦都想要三十万年薪~
10-04 2177
栈与队列~
数据结构——栈和队列
fax_player的博客
09-27 6210
本文详细介绍的栈和队列的实现方式，更是重点提到了4个关于栈和队列的OJ题：分别是设计循环队列，用栈实现队列，用队列实现栈，有效的括号。
数据结构栈与队列题库
闲狗的博客
08-01 1万+
网络课课后题 1、设栈S 和队列Q 的初始状态为空，元素e1，e2，e3，e4，e5和e6依次通过栈S，一个元素出栈后即进队列Q，若6 个元素出队的序列是e2，e4，e3，e6，e5，e1则栈S的容量至少应该是 3 解析：不难，在本子上写写画画就行 2、双端队列可以在队列的两端进行插入和删除操作，既可在队尾进行插入/删除，又可在队头进行插入/删除。现有4个不同的元素顺序输入到双端队列...
【数据结构】栈和队列详解
2403_86779341的博客
06-16 1375
栈和队列详解！！！
GXF 3.2.0 to 4.0 CUDA 12 路径 API 与数据结构增量分析
eloudy的专栏
08-18 247
分析范围：以仓库中与分支对比为基础，聚焦）可用的公共 API 与数据结构变化。由于 GXF 核心头文件在各 CUDA 版本间共享，下列新增/修改的接口在 CUDA 12 构建上同样生效。对比链接：https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_nitros/compare/release-3.2…release-4.0。
快速学会数据结构中的链式队列与循环队列
2401_82745609的博客
08-17 540
一种允许从一端插入数据，另外一端删除数据的线性存储结构称为队列。把数据插入的这端称为队列的队尾， 数据删除这端称为队列的队头。插入操作称为入队；删除操作称为出队。先进先出、后进后出数据缓存。
【数据结构】图的应用：最小生成树（Prim / Kruskal）
最新发布
bianyuan172的博客
08-20 334
摘要：最小生成树（MST）是带权连通无向图中边权总和最小的生成树，常用于网络优化问题。Prim算法从顶点出发，逐步选择连接已选和未选顶点集的最小边，适合稠密图（时间复杂度O(n²)）。Kruskal算法按边权排序后依次选择不构成环的边，适合稀疏图（时间复杂度O(e log e)）。两者均基于贪心策略，但Prim侧重顶点扩张，Kruskal侧重边合并。关键区别在于数据结构（Prim用优先队列，Kruskal用并查集）和适用场景。典型例题需掌握选边过程，记忆口诀为“稠密Prim，稀疏Kruskal”。软考中常考
数据结构 --- 二叉树&哈希表
2401_86288082的博客
08-19 711
本篇数据结构学习笔记分为二叉树、哈希表两大板块。二叉树部分讲解树形基础概念、链式存储方式、前 / 中 / 后序遍历算法，介绍带占位符字符串递归创建二叉树的方法，配套结点计数、深度计算、内存销毁等递归代码实现，补充二叉树核心数学性质。哈希表板块梳理哈希函数、哈希冲突概念，对比开放定址法、链地址法两种冲突解决方案，分析操作的时间复杂度。最后完整给出拉链哈希表五大功能模块的 C 语言实现代码，讲解插入、查找、打印、销毁的执行流程，同时点明现有代码的缺陷与优化方向。
数据结构：双向链表 内核链表 链式队列
yxg0505的博客
08-15 439
本文介绍了链表操作中的几种常用算法技巧。主要包括：1. 快慢指针法（查找中间节点和倒数第k个节点）；2. 链表基本操作（查找、删除特定节点、逆序、排序）；3. 环形链表处理（判断是否有环、获取环入口）；4. 双向链表操作（头插尾插、头删尾删）；5. 内核链表与普通链表的区别；6. 队列的基本概念（FIFO特性）及其应用。这些算法涵盖了链表操作的核心技术，包括单/双向链表处理、环形链表检测以及队列实现等常见数据结构问题。
【数据结构】C语言实现链式二叉树
Jupiter1007的博客
08-18 328
本文系统介绍了链式二叉树的实现与操作，包括节点创建、遍历算法（先序、中序、后序、层序）、节点统计（总数、叶子节点、左右子节点）、高度计算、层级节点查询、节点查找、完全二叉树判断、二叉树翻转和销毁等16个核心功能。重点阐述了递归思想在二叉树操作中的应用，并展示了队列在层序遍历和完全二叉树判断中的关键作用。所有操作均通过C语言实现，提供了完整的代码示例，为理解和实现链式二叉树数据结构提供了全面参考。
408 数据结构｜完全二叉树两道典型题：第 6 层叶结点数与叶结点总数
2301_82049134的博客
08-16 156
除最后一层外：全部满最后一层：允许不满，但必须从左到右连续排列○/ \○ ○/ \ / \○ ○ ○ ○/ \ /○ ○ ○尽量让这一层直接成为最后一层= 39总结点数 = 2n0 - 1或总结点数 = 2n0最少 = 2n0 - 1最多 = 2n0n0 = 124最少 = 2×124 - 1 = 247最多 = 2×124 = 248。
【数据结构】平衡二叉树（AVL）与哈夫曼树
bianyuan172的博客
08-16 270
本文系统讲解了AVL树和哈夫曼树两大高频考点。AVL树通过平衡因子（-1/0/1）实现自平衡，详细解析了LL、RR、LR、RL四种旋转操作及其应用场景，确保查找效率维持在O(log n)。哈夫曼树部分阐述了其构造方法（每次合并最小权值节点）和WPL计算，并给出哈夫曼编码的生成规则。文章配备典型例题和记忆口诀，强调AVL旋转与哈夫曼WPL计算是重点题型，建议重点掌握平衡因子判断与旋转操作，以及哈夫曼树的构建流程。
嵌入式C语言常见考察点（2）
2301_79475128的博客
08-19 163
本文介绍了循环队列实现、 冒泡排序优化、二分查找、 位运算应用、volatile关键字重要性、大小端判断等
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值