栈的实现（C语言完整代码+详细注释版）【数据结构】

已于 2023-03-07 16:01:54 修改
阅读量1.2w 收藏 128
点赞数 29
分类专栏： 数据结构 文章标签： 指针 数据结构 链表 栈
于 2020-08-01 23:01:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45471661/article/details/107738312
版权

含超详细注释的完整且健壮的栈的三种实现方式代码：

顺序栈

//
//  main.c
//  SequenceStack
//
//  Created by Eason on 2020/8/1.
//  Copyright © 2020 Eason. All rights reserved.
//

#include <stdio.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20
typedef int ElemType;
typedef int State;
typedef struct{   //顺序栈的存储结构
    ElemType data[MAXSIZE];   //用数组存放数据，最大为MAXSIZE，作为栈满条件
    int top;   //用作栈顶指针
}SqStack;

//初始化顺序栈
State initStack(SqStack *S){
    S->top = -1;   //将栈顶指针置为-1，即将栈作为还是空的时候
    return OK;
}

//获得顺序栈的长度
int getLength(SqStack S){
    return (S.top)+1;   //根据数组下标的规则，数组中的长度为指针+1个元素
}

//清空顺序栈
State clearStack(SqStack *S){
    S->top = -1;   //将栈顶指针重新设置为-1，即此时表示栈空
    return OK;
}

//判断顺序栈是否为空
State isEmpty(SqStack S){
    if(S.top==-1){   //如果此时栈顶指针为-1表示栈此时为空，非-1则表示非空
        return TRUE;
    }else{
        return FALSE;
    }
}

//入栈
State push(SqStack *S, ElemType *e){
    if(S->top==MAXSIZE-1){   //根据数组下标的特点，当指针指向最后一个元素时为MAXSIZE-1，此时栈满
        printf("栈满，无法入栈\n");
        return ERROR;   //栈满说明空间已满已经不可以再入栈
    }else{    //如果栈非满则执行添加过程
        S->top++;   //栈顶指针+1指向一个新的顶部空间
        S->data[S->top]=e;   //将现在指向的这个新的空的栈顶空间元素置为指定元素（后进先出）
        return OK;
    }
}

//出栈
State pop(SqStack *S, ElemType *e){
    if(S->top==-1){   //当栈顶指针指向-1，说明栈空，则无法出栈
        printf("栈空，无法出栈\n");
        return ERROR;
    }else{   //如果栈非空则执行出栈程序
        *e = S->data[S->top];   //将当前栈顶元素的指针赋给可供返回查看的e
        S->top--;   //栈顶元素出栈后，栈顶指针向下走一格，表示新的栈顶元素
        return OK;
    }
}

//获取栈顶元素（只供查看，不出栈）
State getTop(SqStack S, ElemType *e){
    if(S.top==-1){   //当栈顶指针指向-1，说明栈空，栈顶元素为空
        printf("栈空，无栈顶元素\n");
        return ERROR;
    }else{   //当栈非空的时候，则将栈顶元素赋值给可供返回查看的e，但是栈顶元素并不出栈
        *e = S.data[S.top];   //将栈顶元素赋值给e，栈顶指针top不变
        return OK;
    }
}

//遍历打印顺序栈
State printStack(SqStack S){
    if(S.top==-1){   //当栈顶指针指向-1，说明栈空，无栈元素可供打印
        printf("栈空\n");
        return ERROR;
    }
    int i=0;   //计数器，记录当前是第几个元素
    while(S.top!=-1){
        i++;   //栈顶指针还未到-1，则说明当前栈顶指针有元素，计数器+1
        printf("栈顶向下第%d个元素为：%d\n", i, S.data[S.top]);  //当前栈顶指针的元素打印出
        S.top--;   //栈顶指针向下走一格，继续进行循环打印
    }
    return OK;
}

//测试
int main(int argc, const char * argv[]) {
    SqStack S;
    initStack(&S);
    printf("初始化后的线性栈的长度为：%d\n", getLength(S));
    printf("将1-5元素依次入栈可得：\n");
    for(int i=1;i<=5;i++){
        push(&S, i);
    }
    printStack(S);
    printf("此时顺序栈的长度为：%d\n", getLength(S));
    int e;
    pop(&S, &e);
    printf("出栈：%d\n", e);
    pop(&S, &e);
    printf("出栈：%d\n", e);
    printf("现在顺序栈的长度为：%d\n", getLength(S));
    getTop(S, &e);
    printf("获取栈顶元素：%d\n", e);
    printf("现在顺序栈的长度为：%d\n", getLength(S));
    printf("现在顺序栈的为：\n");
    printStack(S);
    clearStack(&S);
    printf("清空顺序栈后的栈为：\n");
    printStack(S);
    printf("长度为：%d", getLength(S));
    return 0;
}

共享空间栈

//
//  main.c
//  ShareStack
//
//  Created by Eason on 2020/8/1.
//  Copyright © 2020 Eason. All rights reserved.
//

#include <stdio.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20
typedef int ElemType;
typedef int State;
typedef struct{   //定义共享栈的存储结构
    ElemType data[MAXSIZE];   //用数组存储共享栈的数据，并设定最大值判断栈满
    int lefttop;   //左栈的栈顶指针
    int righttop;   //右栈的栈顶指针
}SharedStack;

//初始化共享栈
State initStack(SharedStack *S){
    S->lefttop = -1;   //将左栈与右栈的栈顶指针指向空栈时的默认值，即初始化成功
    S->righttop = MAXSIZE;
    return OK;
}

//获取共享栈的长度
int getLength(SharedStack S){
    return MAXSIZE-(S.righttop-S.lefttop-1);   //根据共享栈的与数组的特性可得，用栈最大存储量减去未存储量即为当前栈的长度
}

//判断共享栈是否为空
State isEmpty(SharedStack S){
    if(S.lefttop==-1 && S.righttop==MAXSIZE){   //如果左栈右栈的栈顶指针均在初始位置即共享栈为空
        return TRUE;
    }else{
        return FALSE;
    }
}

//判断共享栈是否已满
State isFull(SharedStack S){
    if(S.lefttop+1==S.righttop){   //根据共享栈的特性，当左栈的栈顶指针与右栈栈顶指针相邻的时候则表明当前栈已经没有存储空间了
        return TRUE;
    }else{
        return FALSE;
    }
}

//清空共享栈
State clearStack(SharedStack *S){
    S->lefttop=-1;
    S->righttop=MAXSIZE;   //即将共享栈的左右栈顶指针置为初始值则可以代表已经清空了共享栈
    return OK;
}

//入栈（i=0表示入左栈，i=1表示入右栈）
State push(SharedStack *S, int i, ElemType *e){
    if(isFull(*S)){   //判断是否栈满
        printf("栈满，无法入栈");
        return ERROR;
    }
    if(i!=0 && i!=1){   //判断输入的判断左右栈的标志是否有误
        printf("输入有误！请输入插入左栈的代表数字0或右栈代表数字1！");
        return ERROR;
    }
    if(i==0){   //如果i=0则表示进入左栈
        S->lefttop++;  //入栈时栈顶指针向上走一格指向新的空的栈元素位置
        S->data[S->lefttop]=e;  //将该新的栈顶位置给予特定值e
        return OK;  //
    }
    if(i==1){   //如果i=1则表示进入右栈
        S->righttop--;  //入栈时栈顶指针向上走一格指向新的空的栈元素位置
        S->data[S->righttop]=e;  //将该新的栈顶位置给予特定值e
        return OK;
    }
    return OK;
}

//出栈（i=0表示入左栈，i=1表示入右栈）
State pop(SharedStack *S, int i, ElemType *e){
    if(isEmpty(*S)){   //判断当前共享栈是否栈空，若栈空则无元素可出栈
        printf("栈空，无法出栈");
        return ERROR;
    }
    if(i!=0 && i!=1){   //判断输入的判断左右栈的标志是否有误
        printf("输入有误！请输入插入左栈的代表数字0或右栈代表数字1！");
        return ERROR;
    }
    if(i==0){   //如果i=0则表示想要左栈出栈
        *e = S->data[S->lefttop];   //将左栈的栈顶元素出栈赋给可供返回查看的e
        S->lefttop--;   //出栈完成后栈顶指针向下走一格（即向左走一格）指向新的栈顶元素
        return OK;
    }
    if(i==1){   //如果i=1则表示想要右栈出栈
        *e = S->data[S->righttop];   //将右栈的栈顶元素出栈赋给可供返回查看的e
        S->righttop++;   //出栈完成后栈顶指针向下走一格（即向外右一格）指向新的栈顶元素
        return OK;
    }
    return OK;
}

//获取栈顶元素（i=0表示入左栈，i=1表示入右栈）
State getTop(SharedStack S, int i, ElemType *e){
    if(isEmpty(S)){   //判断是否为空栈，若为空栈则无栈顶元素可供查看
        printf("栈空，无栈顶元素");
        return ERROR;
    }
    if(i!=0 && i!=1){   //判断输入的判断左右栈的标志是否有误
        printf("输入有误！请输入插入左栈的代表数字0或右栈代表数字1！");
        return ERROR;
    }
    if(i==0){   //如果i=0则表示想要获取左栈栈顶元素
        *e = S.data[S.lefttop];   //将左栈的栈顶元素出栈赋给可供返回查看的e（仅获取，栈顶指针无需移动）
        return OK;
    }
    if(i==1){   // //如果i=1则表示想要获取右栈栈顶元素
        *e = S.data[S.righttop];   //将右栈的栈顶元素出栈赋给可供返回查看的e（仅获取，栈顶指针无需移动）
    }
    return OK;
}

//打印共享栈（i=0表示入左栈，i=1表示入右栈，i=3表示全栈打印）
State printStack(SharedStack S, int i){
    if(isEmpty(S)){   //判断是否为空栈，若为空栈则无栈元素可打印
        printf("栈空");
        return OK;
    }
    if(i!=0 && i!=1 && i!=3){   //判断输入的判断左右以及全栈的标志是否有误
        printf("输入有误！请输入插入左栈的代表数字0或右栈代表数字1代表全栈的数字3！");
        return ERROR;
    }
    if(i==0){   //如果i=0则表示想要打印左栈元素
        int i=1;   //当前元素位置计数器
        while(S.lefttop!=-1){   //判断当前栈顶指针是否为初始值，若不是则进行打印
            printf("左栈栈顶向下第%d个元素为：%d\n", i, S.data[S.lefttop]);   //打印当前左栈栈顶元素的数据
            S.lefttop--;   //栈顶元素向下走一格继续循环遍历进行打印（向左走一格）
        }
        return OK;
    }
    if(i==1){   //如果i=0则表示想要打印右栈元素
        int i=1;   //当前元素位置计数器
        while(S.righttop!=MAXSIZE){   //判断当前栈顶指针是否为初始值，若不是则进行打印
            printf("右栈栈顶向下第%d个元素为：%d\n", i, S.data[S.righttop]);   //打印当前右栈栈顶元素的数据
            S.righttop++;   //栈顶元素向下走一格继续循环遍历进行打印（向右走一格）
        }
        return OK;
    }
    if(i==3){   //如果i=3则表示想要打印全栈元素
        int i=1;
        while(S.lefttop!=-1){   //同左栈打印步骤
            printf("左栈栈顶向下第%d个元素为：%d\n", i, S.data[S.lefttop]);
            S.lefttop--;
        }
        i=1;  //左栈元素打印完毕，计数器初始化
        while(S.righttop!=MAXSIZE){   //同右栈打印步骤
            printf("右栈栈顶向下第%d个元素为：%d\n", i, S.data[S.righttop]);
            S.righttop++;
        }
    }
    return OK;
}

//测试
int main(int argc, const char * argv[]) {
    SharedStack S;
    initStack(&S);
    printf("初始化一个共享栈，长度为：%d\n", getLength(S));
    printf("将1-5顺序入左栈得：\n");
    for(int i=1;i<=5;i++){
        push(&S, 0, i);
    }
    printStack(S, 0);
    printf("将11-15顺序入右栈得：\n");
    for(int i=11;i<=15;i++){
        push(&S, 1, i);
    }
    printStack(S, 1);
    printf("全栈为：\n");
    printStack(S, 3);
    printf("当前共享栈是否为空（0非空1空)：%d\n", isEmpty(S));
    printf("当前共享栈是否为满（0非满1满)：%d\n", isFull(S));
    printf("当前共享栈的长度为：%d\n", getLength(S));
    int e;
    pop(&S, 0, &e);
    printf("左栈出栈元素：%d\n", e);
    pop(&S, 0, &e);
    printf("左栈出栈元素：%d\n", e);
    pop(&S, 1, &e);
    printf("右栈出栈元素：%d\n", e);
    getTop(S, 0, &e);
    printf("获取当前左栈的栈顶元素：%d\n", e);
    getTop(S, 1, &e);
    printf("获取当前右栈的栈顶元素：%d\n", e);
    printf("现在共享栈的元素为：\n");
    printStack(S, 3);
    printf("现在共享栈的长度为：%d\n", getLength(S));
    return 0;
}

链栈

//
//  main.c
//  LinkStack
//
//  Created by Eason on 2020/8/1.
//  Copyright © 2020 Eason. All rights reserved.
//

#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int ElemType;
typedef int Status;
typedef struct StackNode{   //链栈的结点存储结构
    ElemType data;   //数据域
    struct StackNode *next;  //指针域
}*StackNodePtr,StackNode;   //StackNodePtr 即struct StackNode {}*

typedef struct{   //链栈头指针的存储结构
    StackNodePtr top;   //链栈头指针
    int count;   //链栈的元素数量计数器
}LinkedStack;

//初始化链栈
Status initStack(LinkedStack *L){
    L->top = (StackNodePtr)malloc(sizeof(StackNode));   //为头结点分配内存空间
    if(!L->top){   //判断内存空间是否分配成功
        return ERROR;
    }
    L->top = NULL;   //空链栈的头结点指针指向空
    L->count = 0;   //链栈内的结点数量初始为0
    return OK;
}

//判断链栈是否为空
Status isEmpty(LinkedStack L){
    if(L.count==0){   //若此时链栈头结点中的计数器为0则说明链栈为空
        return TRUE;
    }else{
        return FALSE;
    }
}

//清空链栈
Status clearStack(LinkedStack *L){
    StackNodePtr p, q;   //定义临时链栈结点
    p = L->top;   //将p作为首个结点
    while(p){   //如果p存在的话则继续循环执行循环体
        q=p;   //将p赋给q
        p=p->next;   //p向下继续进行
        free(q);   //将q释放掉，即完成了p区域的清理，然后继续循环判断
    }
    L->count=0;   //将链栈头结点中的计数器归零
    return OK;
}

//获取链栈的长度
int getLength(LinkedStack L){
    return L.count;   //链栈的长度就是头结点中的计数器数值
}

//链栈的入栈
Status push(LinkedStack *L, ElemType *e){
    StackNodePtr p = (StackNodePtr)malloc(sizeof(StackNode));  //为入栈元素分配内存空间
    p->data=e;  //将新元素的数据域置为指定值
    p->next = L->top;   //将目前的首个结点置为新结点的下一个结点
    L->top = p;   //然后将首个结点设置为p
    L->count++;   //入栈成功，头结点的计数器+1
    return OK;
}

//链栈的出栈
Status pop(LinkedStack *L, ElemType *e){
    StackNodePtr p;   //定义临时结点
    if(isEmpty(*L)){   //出栈先判断当前栈是否为空，为空则没有栈顶元素可以出栈
        printf("链栈为空，无法出栈\n");
        return ERROR;
    }
    p = L->top;   //将p作为链栈的首个结点，即栈顶结点
    *e = p->data;   //将栈顶结点的值赋给e以供返回查看
    L->top = p->next;   //将首个结点的下个结点作为头结点的下个结点（即重新设置首个结点）
    free(p);   //将老的栈顶结点p释放掉
    L->count--;   //出栈成功，头结点的计数器-1
    return OK;
}

//获取链栈的栈顶元素
Status getTop(LinkedStack L, ElemType *e){
    if(isEmpty(L)){   //要获取栈顶元素首先判断当前链栈是否为空栈，若为空栈则无栈顶元素可供获取
        printf("链栈为空，无栈顶元素\n");
        return ERROR;
    }
    *e = L.top->data;   //链栈不为空，则将此时的栈顶元素的数据赋给e以供返回查看
    return OK;
}

//链栈的打印
Status printStack(LinkedStack L){
    if(isEmpty(L)){   //判断链栈是否为空，若为空则无元素可供打印
        printf("链栈为空，无元素可打印\n");
        return ERROR;
    }
    StackNodePtr p;   //定义临时结点p
    int i = 0; //当前位置计数器
    p=L.top;   //将p设置为首个结点
    while(p){   //若p存在的话则执行循环体
        i++;   //若存在则说明当前位置要+1
        printf("链栈由栈顶向下的第%d个元素为：%d\n", i, p->data);   //将当前结点（即栈顶元素）输出
        p = p->next;   //栈顶位置继续向下，循环到p不存在
    }
    return OK;
}

//测试
int main(int argc, const char * argv[]) {
    LinkedStack L;
    initStack(&L);
    printf("初始化链栈后链栈L的长度为：%d\n", getLength(L));
    printf("此时链栈为空为吗？(1为是，0为否）：%d\n", isEmpty(L));
    printf("将1-8顺序入栈得：\n");
    for(int i=1;i<=8;i++){
        push(&L, i);
    }
    printStack(L);
    printf("此时的链栈长度为：%d\n", getLength(L));
    int e;
    getTop(L, &e);
    printf("此时的栈顶元素为：%d\n", e);
    pop(&L, &e);
    printf("出栈：%d\n", e);
    pop(&L, &e);
    printf("出栈：%d\n", e);
    printf("现在的链栈内容为：\n");
    printStack(L);
    getTop(L, &e);
    printf("现在的栈顶元素为：%d\n", e);
    printf("现在链栈的长度为：%d\n", getLength(L));
    printf("清空链栈后的链栈为：\n");
    clearStack(&L);
    printStack(L);
    return 0;
}
 ⁢Easonhe
关注
  • 29
    点赞
  • 踩
  • 128
    收藏
    觉得还不错? 一键收藏
  • 18
    评论
专栏目录
数据结构——栈（代码
weixin_51460943的博客
04-18 775
栈的链式存储，基本操作实现 （带头结点，不带头结点） //栈的链式存储 #include<stdio.h> #include<stdlib.h> typedef int ElemType; //数据类型描述 (定义) typedef struct Linknode{ ElemType data; struct Linknode *next; }Linknode,*LiStack; //初始化(带头结点） bool InitStackWithHead(LiStack
栈的实现程序代码(c语言)
06-03
栈的实现程序代码(c语言) 数据结构学习必备
【数据结构】栈(实现+原码)
Edward_Asia的博客
10-31 1161
栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。 栈中的数据元素遵守后进先出LIFO（Last In First Out）原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。 #pragma once #include<s.
C语言数据结构--栈 基本操作代码合集
最新发布
m0_70744482的博客
04-05 413
三段代码分别是栈的顺序存储，带头结点的链式存储，不带头结点的链式存储。都包括着初始化、判空、进栈、建立栈表、出栈，读取栈顶元素、遍历操作，方便大家调试。
c语言写栈,C语言写栈
weixin_30000283的博客
05-20 226
文章目录一、栈的定义栈(stack)是限定仅在表尾进行插入或者删除的线性表。对于栈来说，表尾端称为栈顶(top)，表头端称为栈低(bottom)。不含元素的空表称为空栈。因为栈限定在表尾进行插入或者删除，所以栈又被称为后进先出的线性表。二、栈的基本操作(一) 栈的顺序存储结构(基于数组)栈的创建typedef struct{int data[N];int top;}Sqstack;栈的初始化voi...
堆栈（Stack）实现（C++）
weixin_43361652的博客
01-28 5667
一. 堆栈（Stack） 堆栈（Stack） 是一种可以存取的数据结构，其主要特征是先进后出（Last-in-first-out, LIFO） 栈顶（Top） 是最后入栈的数据 堆栈可分为静态堆栈（Static Stack）和动态堆栈（Dynamic Stack）两类： Static Stack： 栈的大小固定，可以用数组实现； Dynamic Stack： 栈的大小随需要改变，可以用链表实现 二. 基本操作（Basic Operation） 入栈（Push）：Equivalent to an in
栈的实现（c语言）--- 数据结构
不倒翁.
10-05 532
1. 栈的简介 1.1栈的特点 栈(Stack)是一种线性存储结构，它最大的特点就是：栈中的数据遵循先进后出的原则，想要在栈中插入和删除数据，只能在栈顶操作。 1.2栈的相关概念 栈的相关概念： 1.栈顶与栈底：允许元素插入与删除的一端称为栈顶，另一端称为栈底。 2.入栈：栈的插入操作，叫做进栈，也称压栈。 3.出栈：栈的删除操作，也叫做弹栈。 下面我将介绍栈的两种实现结构，一种是栈的顺序存储，一种是栈的链式存储。 2.栈的顺序存储 一般对于栈的操作主要有以下几个部分： 1.初始化栈，也就是创建出一个栈的结
关于栈的创建以及基本操作（c语言）
m0_64028711的博客
04-11 3550
最近在网上寻找了不少关于栈的知识，由此特来记录本人的一些心得。 栈和表一样，分为顺序栈和链栈，我们先来讲简单的顺序栈。 顺序栈其实和顺序表差别不大，以下是顺序栈的创建： #include<stdio.h> #include<stdlib.h> #define max 100 typedef struct Tack{ int *data; int top; }Tack; 创建好后就得初始化； void inTack(Tack *s) {
C语言创建堆栈（顺序栈） 详细分析附源码
喜欢数学建模的大一小白
11-10 2033
C语言创建堆栈 初始化 销毁 压栈入栈 判断上溢下溢
栈的C语言实现
一
10-08 1万+
一个栈的C语言实现,函数声明放在stack.h头文件汇总，函数定义放在stack.c中，main.c 用来测试各个函数. 1.文件 stack.h // stack.h #ifndef __STACK_H__ #define __STACK_H__ typedef int DataType; typedef struct node{ DataType data; ...
数据结构与算法全集（C源代码+详细注释）
11-27
全集内容结构如下： ├─图 │ ├─关键路径（有向无环图及其应用2） │ │ 1.txt │ │ ALGraph.cpp │ │ ALGraph.h │ │ CriticalPath.cpp │ │ CriticalPath.h │ │ InfoType.cpp │ │ InfoType.h │ │ ...
数据结构栈和队列（参考代码）
06-18
数据结构栈和队列的课程指导上几实验代码 相抵部分
数据结构C语言代码示例，有详细注释
02-16
数据结构C语言 单链表 0_SingleLinkList.c 双链表 1_DualLinkList.c 递归 2_Recursion.c 栈 3_Stack.c 汉诺塔 4_Hanoi.c 二叉树 5_BinaryTree.c 最小堆 6_MinHeap.c 哈夫曼树 7_HuffmanTree.c 邻接...
严蔚敏版《数据结构》代码实现
01-13
这些代码主要是针对严蔚敏老师的《数据结构》一书中的大部分伪代码编辑的代码，能够正常运行，是基于C++编写的代码，包括，数组线性表，链表线性表、双向链表、顺序栈、链栈、链队列，顺序队列，循环队列、KMP算法、...
数据结构-栈(C语言)
10-18
栈的简单实现，函数出栈入栈，代码简单，含注释，适合初学者
数据结构（C语言版）严蔚敏
09-02
, 全书采用C语言作为数据结构和算法的描述语言，对数据结构的定义和算法的描述详细，代码注释完整，便于初学者模仿训练，循序渐进地获得稳步提高。本书既可作为高等学校计算机科学与技术、软件工程和通信工程等信息...
栈、队列(详细图解与代码实现)
YOLO97的博客
09-07 3914
栈 栈是一种只能在一端进行插入和删除的线性数据结构。主要有进栈(Push)和出栈(POP)两个操作。 - 栈的存储结构 栈一般使用一段连续的空间进行存储，通常预先分配一个长度，可以简单地使用数组去实现，具体的存储结构如下图所示： - 栈的特点 只能在一端进行操作，在遵循先进后出(FILO,First In Last Out)或后进先出(LIFO,Last In First Out...
栈的简单代码
cynicme的博客
03-31 82
#include<iostream> using namespace std; template <class T> class SeqStack { public: SeqStack() { top = -1; } ~SeqStack() {} void Push(T x); T pop(); T GetTop(); int Empty(); private: T data[100]; int top; }; template<class T>
数据结构之 栈（C语言实现）
热门推荐
men_wen的博客
03-14 1万+
数据结构之 栈（C语言实现）1.栈的模型栈（stack）是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫做栈的顶（top）。对栈的基本操作有push（进栈）和pop（出栈），前者相当于插入，后者则是删除最后插入的元素。最后插入的元素可以通过使用top例程在执行pop之前进行考察。对空栈进行的pop或top一般被认为是栈ADT的错误。另一方面，当运行push时空间用尽是一个实现错误，但不
数据结构C语言源代码及详细注释
03-27
很抱歉，我作为AI语言模型无法提供完整的数据结构C语言源代码及详细注释。但我可以为您提供一些数据结构C语言的基本概念和相关学习资源。 数据结构是计算机科学中的一个重要概念，它指的是一组数据的组织方式、存储方式以及操作方式。数据结构可以分为线性结构和非线性结构。常见的线性结构有数组、链表、栈和队列等，非线性结构有树、图等。 在C语言中，可以使用结构体和指针来实现各种数据结构。例如，链表可以使用结构体和指针实现，代码如下： ``` //定义链表节点结构体 struct ListNode { int val; struct ListNode* next; }; //创建链表 struct ListNode* createList(int* nums, int numsSize) { struct ListNode* head = NULL; struct ListNode* tail = NULL; for (int i = 0; i < numsSize; i++) { struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode)); node->val = nums[i]; node->next = NULL; if (head == NULL) { head = node; tail = node; } else { tail->next = node; tail = node; } } return head; } //遍历链表 void traverseList(struct ListNode* head) { struct ListNode* p = head; while (p != NULL) { printf("%d ", p->val); p = p->next; } printf("\n"); } //插入节点到链表 struct ListNode* insertList(struct ListNode* head, int val) { struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode)); node->val = val; node->next = NULL; if (head == NULL) { head = node; } else { struct ListNode* p = head; while (p->next != NULL) { p = p->next; } p->next = node; } return head; } //删除链表节点 struct ListNode* deleteList(struct ListNode* head, int val) { if (head == NULL) { return NULL; } if (head->val == val) { struct ListNode* p = head; head = head->next; free(p); return head; } struct ListNode* p = head; while (p->next != NULL && p->next->val != val) { p = p->next; } if (p->next != NULL) { struct ListNode* q = p->next; p->next = q->next; free(q); } return head; } //销毁链表 void destroyList(struct ListNode* head) { struct ListNode* p = head; while (p != NULL) { struct ListNode* q = p->next; free(p); p = q; } } int main() { int nums[] = {1, 2, 3, 4, 5}; int numsSize = sizeof(nums) / sizeof(int); struct ListNode* head = createList(nums, numsSize); traverseList(head); head = insertList(head, 6); traverseList(head); head = deleteList(head, 3); traverseList(head); destroyList(head); return 0; } ``` 以上代码演示了如何使用结构体和指针实现链表的创建、遍历、插入、删除和销毁等操作。 如果您想深入学习数据结构和算法，可以参考以下学习资源： - 《算法导论》 - 《数据结构与算法分析》 - 《数据结构与算法》（王道考研系列） - LeetCode网站上的数据结构和算法题目

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值