数据结构----栈+队列完整C代码(代码易懂)

最新推荐文章于 2024-01-15 15:25:38 发布
最新推荐文章于 2024-01-15 15:25:38 发布
阅读量2.2k 收藏 28
点赞数 6
分类专栏： 数据结构基础 文章标签： 数据结构 队列 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45637300/article/details/107604945
版权

前言

本篇博客依旧适合那些学过数据结构中栈及队列知识的人，不适合那些刚开始接触这个相关知识的读者，当然的话，如果你是未入门这门知识，你可以先收藏起来，等你学完这个相关知识后，可以看一下这篇博客。好了，话不多说，直接整代码吧。

栈的链式存储结构

//栈的链式存储结构
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<time.h>
#include<windows.h>
typedef char ElemType;
typedef int Status;
typedef struct stackNode{
    ElemType data;
    struct stackNode *next;
}stackNode,*LinkStackPtr;
typedef struct LinkStack{
    LinkStackPtr top;
    int count;
}LinkStack;
//初始化栈
Status InitStack(LinkStack *s){
    LinkStackPtr p;
    s->top=NULL;
    p->next=NULL;
    s->count=0;
}
//进栈操作
Status Push(LinkStack *s,ElemType e){
    LinkStackPtr p=(LinkStackPtr)malloc(sizeof(stackNode));
    p->data=e;
    p->next=s->top;
    s->top=p;
    s->count++;
}
//出栈操作
Status Pop(LinkStack *s,ElemType *e){
    LinkStackPtr p;
    if(StackEmpty(*s)){
        printf("栈空，无法出栈\n");
    }
    *e=s->top->data;
    p=s->top;
    s->top=s->top->next;
    free(p);
    s->count--;
    printf("出栈完毕\n");
}
//判断栈是否为空
Status StackEmpty(LinkStack *s){
    if(!s->top){
        return 1;
    }
    else{
        return 0;
    }
}
int main(){
    int choice=0;
    LinkStack s;
    while(choice!=5){
        printf("**********菜单**********\n");
        printf("|1.进栈操作   2.出栈操作|\n");
        printf("|3.初始化栈   4.判断栈是否为空|\n");
        printf("|5.退出程序|\n");
        printf("(注意:在进行所有操作时,必须提前进行初始化栈操作)\n");
        printf("请输入你的选择:");
        scanf("%d",&choice);
        switch(choice){
            case 1:{
                char e;
                printf("请输入要进栈的字符:");
                scanf("%c",&e);
                while(e!='#'){
                    Push(&s,e);
                    scanf("%c",&e);
                }
                printf("进栈操作完毕\n");
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 2:{
                char e;
                Pop(&s,&e);
                printf("出栈的字符为:%c\n",e);
                printf("出栈操作完毕\n");
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 3:{
                InitStack(&s);
                printf("初始化完成\n");
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 4:{
                int flag=StackEmpty(&s);
                if(flag){
                    printf("栈空\n");
                }
                else{
                    printf("栈不为空\n");
                }
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 5:{
                printf("程序退出\n");
                break;
            }
        }
    }
    return 0;
}

队列顺序存储结构

//队列的顺序存储结构
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<windows.h>
#include<time.h>
#define MAXSIZE 20
typedef int ElemType;
typedef int Status;
typedef struct{
    ElemType *base;
    int front;
    int rear;
}cycleQueue;
//初始化
Status initQueue(cycleQueue *q){
    q->base=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));
    if(!q->base){
        printf("初始化失败\n");
        exit(0);
    }
    q->front=q->rear=0;
    printf("初始化操作完毕\n");
}
//入队操作
Status InsertQueue(cycleQueue *q,ElemType e){
    if((q->rear+1)%MAXSIZE==q->front){
        printf("队列已满，无法入队\n");
        return 0;
    }
    q->base[q->rear]=e;
    q->rear=(q->rear+1)%MAXSIZE;
    printf("入队完毕\n");
}
//出队操作
Status DeleteQueue(cycleQueue *q,ElemType *e){
    if(q->front==q->rear){
        printf("队空，出队失败\n");
        return 0;
    }
    *e=q->base[q->front];
    q->front=(q->front+1)%MAXSIZE;
    printf("出队元素值为:%d\n",*e);
    printf("出队完毕\n");
}
//销毁队列
Status DestroyQueue(cycleQueue *q){
    if(q->base){
        free(q->base);
    }
    q->base=NULL;
    q->front=q->rear=0;
    printf("销毁完毕\n");
}
int main(){
    int choice=0;
    cycleQueue q;
    while(choice!=5){
        printf("**********菜单**********\n");
        printf("|1.初始化操作   2.销毁队列|\n");
        printf("|3.入队操作     4.出队操作|\n");
        printf("|5.退出程序|\n");
        printf("(注意:在进行操作时，必须提前进行初始化操作)\n");
        printf("请输入你的选择:");
        scanf("%d",&choice);
        switch(choice){
            case 1:{
                initQueue(&q);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 2:{
                DestroyQueue(&q);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 3:{
                int e;
                printf("请输入要入队元素的值:");
                scanf("%d",&e);
                InsertQueue(&q,e);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 4:{
                int *e;
                DeleteQueue(&q,&e);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 5:{
                printf("程序退出\n");
                system("cls");
                break;
            }
        }
    }
    return 0;
}

队列的链式存储结构

//队列链式结构
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<windows.h>
#include<time.h>
typedef int Status;
typedef int ElemType;
typedef struct QNode{
    ElemType data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct {
    QueuePtr front,rear;
}LinkQueue;
//创建队列操作
Status initQueue(LinkQueue *q){
    q->front=q->rear=(QueuePtr)malloc(sizeof(QNode));
    if(!q->front){
        exit(0);
    }
    q->front->next=NULL;
    printf("初始化完毕\n");
}
//入队操作
Status InsertQueue(LinkQueue *q,ElemType e){
    QueuePtr p;
    p=(QueuePtr)malloc(sizeof(QNode));
    if(p==NULL){
        printf("入队操作失败\n");
        exit(0);
    }
    p->data=e;
    p->next=NULL;
    q->rear->next=p;
    q->rear=p;
    printf("入队操作完毕\n");
}
//出队操作
Status DeleteQueue(LinkQueue *q,ElemType *e){
    QueuePtr p;
    if(q->front==q->rear){
        printf("出队操作失败\n");
        return 0;
    }
    p=q->front->next;
    *e=p->data;
    q->front->next=p->next;
    if(q->rear==p){
        q->rear=q->front;
    }
    printf("出队的元素为:%d\n",*e);
    free(p);
}
//销毁队列
Status DestroyStack(LinkQueue *q){
    while(q->front){
        q->rear=q->front->next;
        free(q->front);
        q->front=q->rear;
    }
    printf("销毁完毕\n");
}
int main(){
    int choice=0;
    LinkQueue q;
    while(choice!=5){
        printf("**********菜单**********\n");
        printf("|1.初始化操作   2.销毁操作|\n");
        printf("|3.入队操作     4.出队操作|\n");
        printf("|5.退出程序|\n");
        printf("(注意:在进行入队，出队操作时，必须提前进行初始化操作)\n");
        printf("请输入你的选择:");
        scanf("%d",&choice);
        switch(choice){
            case 1:{
                initQueue(&q);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 2:{
                DestroyStack(&q);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 3:{
                int e;
                printf("请输入要入队元素值:");
                scanf("%d",&e);
                InsertQueue(&q,e);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 4:{
                int e;
                DeleteQueue(&q,&e);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 5:{
                system("cls");
                printf("程序退出\n");
                break;
            }
        }
    }
    return 0;
}

大家可能会好奇，上面三段代码，缺少了栈的顺序存储结构。其实，我在写栈的顺序存储结构的代码时参考过其他人的代码，但是自己写完后，程序运行时，出现很多奇奇怪怪的bug，所以我在下面向大家求助一下，希望大家能够帮我找出bug。

栈的顺序存储结构

#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include<time.h>
#include<malloc.h>
#define MAXSIZE 20
typedef int Status;
typedef char ElemType;
typedef struct{
    ElemType *top;
    ElemType *base;
    int stackSize;
}sqStack;
//初始化操作
Status initStack(sqStack *s){
    s->base=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));
    if(!s->base){
        printf("内存错误\n");
        exit(0);
    }
    s->top=s->base;
    s->stackSize=MAXSIZE;
    printf("创建成功\n");
}
//进栈操作
Status Push(sqStack *s,ElemType e){
    //栈满，扩展栈空间
    if(s->top-s->base>=s->stackSize){
        s->base=(ElemType *)realloc(s->base,(MAXSIZE+s->stackSize)*sizeof(ElemType));
    }
    s->top=s->base+s->stackSize;
    s->stackSize=s->stackSize+MAXSIZE;
    *(s->top)=e;
    s->top++;
}
//出栈操作
Status Pop(sqStack *s,ElemType *e){
    if(s->base==s->top){
        printf("栈空，无法出栈\n");
        return 0;
    }
    *e=*(s->top-1);
    s->top--;
    printf("出栈成功,出栈元素值为:%c\n",*e);
}
//清空栈
Status ClearStack(sqStack *s){
    s->base=s->top;
    printf("清空完毕\n");
}
//销毁栈
Status DestroyStack(sqStack *s){
    int len;
    len=s->stackSize;
    for(int i=0;i<len;i++){
        free(s->base);
        s->base++;
    }
    s->top=s->base=NULL;
    s->stackSize=0;
    printf("销毁成功\n");
}
//栈的当前容量
Status StackLen(sqStack *s){
    return (s->top-s->base);
}
int main(){
    int choice=0;
    sqStack s;
    while(choice!=7){
        printf("***************菜单***************\n");
        printf("|1.创建栈   2.清空栈|\n");
        printf("|3.销毁栈   4.返回栈容量|\n");
        printf("|5.进栈     6.出栈|\n");
        printf("|7.退出程序|\n");
        printf("请输入你的选择:");
        scanf("%d",&choice);
        switch(choice){
            case 1:{
                initStack(&s);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 2:{
                ClearStack(&s);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 3:{
                DestroyStack(&s);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 4:{
                int len=StackLen(&s);
                printf("栈的容量为:%d\n",len);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 5:{
                char e;
                printf("请输入一串字符:");
                scanf("%c",&e);
                //以#结束循环
                while(e!='#'){
                    Push(&s,e);
                    scanf("%c",&e);
                }
                getchar();
                printf("进栈操作完毕\n");
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 6:{
                char e;
                Pop(&s,&e);
                printf("程序将自动跳转到菜单页面\n");
                Sleep(1000);
                system("cls");
                break;
            }
            case 7:{
                printf("程序退出\n");
                system("cls");
                break;
            }
        }
    }
    return 0;
}

大家可以运行程序，调试一下该段代码，可以发现其中的bug。当然，我这里有一份别人写的栈的顺序存储结构代码，网址为:https://www.cnblogs.com/wjundong/p/11623224.html

希望能够帮助到大家!

参考资料

<<大话数据结构>>

A神经质
关注
  • 6
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】栈(stack)、队列(queue)【顺序栈+可扩容顺序栈+链式栈】【循环可扩容队列+链式队列】（C语言代码）
crr411422的博客
03-23 821
基础扫盲：栈(stack)、队列(queue)的图文理解。（可根据自身情况略过该部分） 栈实现：顺序栈+可扩容循序栈+链式栈（完整代码） 队列实现：循环可扩容队列+链式队列（完整代码）
数据结构之队列（顺序队和链队）（C语言附完整代码）
m0_62795460的博客
04-12 5978
队列简称队，它是一种操作受限的线性表，其限制为仅允许在表的一端进行插入操作，而在表的另一端进行删除操作。把进行插入的一端称为队尾，把进行删除的一端称为队头或队首。向队列中插入新元素称为进队或入队，从队列中删除元素称为出队或离队。由于队列的插入和删除操作分别是在各自的一端进行的，每个元素必然按照进入的次序出队，所以又把队列称为先进先出表。采用顺序存储结构的队列称为顺序队声明顺序队//存放队中元素 int front , rear;//队首和队尾指针 } SqQueue;采用链式存储结构的队列称为链队。
栈和队列详解（含代码演示）
Guqing_f的博客
04-27 809
1.栈 栈是一种只能在一段进行插入和删除的线性数据结构，通常使用线性表来实现。栈满足 **后进先出（LIFO/ last in first out）**的特性 由于栈不能像线性表一样随意进行插入删除，因此可以将栈视为一种功能受限的线性表。 栈的管理结点和线性表的管理结点相同： 顺序表实现栈：数据域(data)、栈的总容量(total)、栈的大小(len) 链表实现栈：栈顶结点(头结点)的指针(*head)、栈的大小(len) （1）顺序栈的增删改查 【顺序栈也可以使用和顺序表一样的扩容方式】 #includ
数据结构栈实现（赋完整代码）
wjfwonderful的博客
01-15 377
1.栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。2.进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。3.压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。出栈：栈的删除操作叫做出栈。出数据也在栈顶。
数据结构中栈和队的源代码
10-22
这个是我写的数据结构的源代码，里面是我写的基本的栈的结构，还有的是基本的队，然后就是循环队列了
数据结构 栈和队列的详细代码~
11-28
数据结构 栈和队列的详细代码~数据结构 栈和队列的详细代码~数据结构 栈和队列的详细代码~数据结构 栈和队列的详细代码~
数据结构-浙江大学-陈越.zip
最新发布
06-16
1. **讲义**：通常，陈越教授的讲义会详细解释各种数据结构的概念，如数组、链表、栈、队列、树（二叉树、平衡树如AVL树、红黑树等）、图、散列表等。讲义会涵盖这些数据结构的基本定义、操作（插入、删除、查找）、...
数据结构(c语言版)谭浩强著--课本代码第四章
03-03
"数据结构(c语言版)谭浩强著--课本代码第四章"显然是针对谭浩强编著的数据结构教材的第四章内容，这部分可能涉及到了数组、链表、栈、队列、树等基础数据结构，也可能涵盖了排序和搜索算法。 1. **数组**：数组是最...
sort-name-by-read.rar_数据结构_C/C++_
08-11
数据结构是存储和组织数据的方式，包括数组、链表、栈、队列、树、图等。在这个场景中，可能使用的是数组或链表来存储学生的信息，如姓名、学号等。数组是一种线性数据结构，它将元素存储在连续的内存位置，而链表则...
印度小哥数据结构视频代码
02-27
最后，“p22用数组实现队列并进行入队出队操作.c”和“p33使用队列按层次遍历打印二叉树结点.c”讨论了队列这一线性数据结构。队列遵循先进先出（FIFO）原则，数组实现简单直观，层次遍历二叉树则需要用到队列来逐层...
数据结构栈和队列（参考代码）
06-18
数据结构栈和队列的课程指导上几实验代码 相抵部分
C++栈和队列底层_数据结构与算法实验二_艾孜尔江·艾尔斯兰著.zip
01-01
通俗易懂，由艾孜尔江·艾尔斯兰亲自实验并撰著而成，均为底层开发，可供研究和学习使用，平时工作中亦可实践，是初学者深入学习数据结构与算法的法宝，基于C++语言实现，涉及到C语言的内容较多，内含指导教程和详细...
【数据结构】栈(实现+原码)
Edward_Asia的博客
10-31 1172
栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。 栈中的数据元素遵守后进先出LIFO（Last In First Out）原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。 #pragma once #include<s.
【数据结构】栈的代码实现
HelloCode
05-16 1727
🌟个人博客：www.hellocode.top🌟 ⭐所有文章均在上方博客首发，其他平台同步更新 🔥本文专栏：《数据结构与算法》 ⚡如有问题，欢迎指正，一起学习~~ 文章参考整理自小码哥的《恋上数据结构和算法》课程，图片转载自课程PPT，如有侵权，请联系删除~~ 文章目录接口设计代码实现 栈是一种特殊的线性表, 只能在一端进行插入或者删除操作 往栈中添加元素的操作，一般叫做push，入栈 从栈中移除元素的操作，一般叫做pop，出栈(只能移除栈顶的元素) 成员变量无非就是size和一个element.
栈、队列(详细图解与代码实现)
YOLO97的博客
09-07 3915
栈 栈是一种只能在一端进行插入和删除的线性数据结构。主要有进栈(Push)和出栈(POP)两个操作。 - 栈的存储结构 栈一般使用一段连续的空间进行存储，通常预先分配一个长度，可以简单地使用数组去实现，具体的存储结构如下图所示： - 栈的特点 只能在一端进行操作，在遵循先进后出(FILO,First In Last Out)或后进先出(LIFO,Last In First Out...
数据结构-顺序栈的基本操作的实现（含全部代码）
热门推荐
关注网络安全、云原生安全
09-15 7万+
主要操作函数如下： InitStack(SqStack &s) 参数：顺序栈s 功能：初始化 时间复杂度O(1) Push(SqStack &s,SElemType e) 参数：顺序栈s,元素e 功能：将e入栈 时间复杂度:O(1) Pop(SqStack &s,SElemType &e) 参数：顺序栈s,元素e 功能：出栈,e接收出...
数据结构——栈（代码
weixin_51460943的博客
04-18 780
栈的链式存储，基本操作实现 （带头结点，不带头结点） //栈的链式存储 #include<stdio.h> #include<stdlib.h> typedef int ElemType; //数据类型描述 (定义) typedef struct Linknode{ ElemType data; struct Linknode *next; }Linknode,*LiStack; //初始化(带头结点） bool InitStackWithHead(LiStack
c++ 栈和栈的应用（图解）
qq_62309585的博客
09-08 5043
图解 栈 后缀表达式等
线性表的链式存储结构(完整代码(C语言)+运行实例)
weixin_45637300的博客
04-09 1万+
代码如下: #include <stdio.h> #include <stdlib.h> #define ERROR 0 #define OK 1 typedef int Status; typedef int ElemType; typedef struct Node{ ElemType data; struct Node *next; }Node; ty...
C语言中数据结构试题及答案.doc
06-02
C语言中数据结构试题及答案.doc

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值