栈的基本操作（详细）

最新推荐文章于 2024-05-31 08:49:19 发布
最新推荐文章于 2024-05-31 08:49:19 发布
阅读量1.5w 收藏 245
点赞数 24
文章标签： c++ c语言 开发语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43346784/article/details/125634848
版权

本文章会详细介绍栈的基本操作

目录

1.本文章中全部实现的功能

2.建栈

3.输入栈内元素(由于起初输入栈不牵扯到栈的扩容，所以对此部分注释)

4.进栈

5.弹栈，并且返回出弹栈元素

6.栈内元素的个数

7.按栈输入的顺序输出栈里面的值

8.按栈弹出的顺序输出栈

9.判断栈是否为空

10.获取栈顶元素

11.清空一个栈

12.摧毁一个栈

13.switch功能语句

14.全部代码

15.运行结果

1.本文章中全部实现的功能

        栈的特点，先进后出。

void program()
{
    printf("\t请输入以下功能数字\n");
    printf("\t0.退出\n");
    printf("\t1.判断栈是否为空\n");
    printf("\t2.按栈弹出的顺序输出栈\n");
    printf("\t3.按栈输入的顺序输出栈里面的值\n");
    printf("\t4.获取栈顶元素\n");
    printf("\t5.摧毁一个栈\n");
    printf("\t6.清空一个栈\n");
    printf("\t7.求栈的长度\n");
    printf("\t8.弹栈，并且返回出弹栈元素\n");
    printf("\t9.输入栈内数据\n");
    printf("\t10.在清空的基础下重新建立栈\n");
    printf("\t11.请输入想要插入栈顶的元素\n");

}

2.建栈

Status InitStack(SqStack &S)
{
    //建栈
    S.base=(int*)malloc(Stack_Init_Size*sizeof(int));
    if(!S.base) exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=Stack_Init_Size;
    return OK;
}

3.输入栈内元素(由于起初输入栈不牵扯到栈的扩容，所以对此部分注释)

SqStack InputStack(SqStack &S)
{   
    int a;
    /*scanf("%d",&a);
    while(a!=-1)
    {   
            if(S->top-S->base>S->stacksize)
            {
            S->base=(int *)realloc(S->base,(Stack_Init_Size+Stack_Increment)*sizeof(int));
            if(!S->base) printf("NoRealloc\n");
            S->top=S->base+S->stacksize;
            S->stacksize=S->stacksize+Stack_Increment;
            }
            *S->top++ = a;
            scanf("%d",&a);
    }*/
    InitStack(S);
    printf("\t");
    for(int i=0;;i++){
    scanf("%d",&a);
    if(a==-1)break;
    *S.top++ =a;
    }
    printf("\t写入完成\n");
}

4.进栈

        如果栈的内容小于输入内容不需要扩展直接*S.top++=e;但是当内容大于了栈的内容。就进入if语句。

Status Push(SqStack &S,int e)
{
    //进栈
    if(S.top-S.base>S.stacksize)
    {
        S.base=(int *)realloc(S.base,(Stack_Init_Size+Stack_Increment)*sizeof(int));
        if(!S.base) printf("NoRealloc\n");
        S.top=S.base+S.stacksize;
        S.stacksize=S.stacksize+Stack_Increment;
    }
    *S.top++=e;
    return OK;
}

5.弹栈，并且返回出弹栈元素

Status Pop(SqStack &S,int *e)
{   
    //弹栈，并且返回出弹栈元素
    *e=*--S.top;
    return OK;
}

6.栈内元素的个数

Status StackLength(SqStack S)
{   
    //栈长
    int Length=S.top-S.base;
    printf("\tlength = %d\n",Length);
    return Length;
}

7.按栈输入的顺序输出栈里面的值

void PrintStack_int(SqStack S)
{
    //按栈输入的顺序输出栈里面的值
    int *p=S.base;
    while(p!=S.top)
    {   
        printf("\t");
        printf(" %d ",*p);
        p++;
    }
    printf("\n");
}

8.按栈弹出的顺序输出栈

void PrintStack_Pop(SqStack S)
{   
    //按栈弹出的顺序输出栈
    int *p=S.top-1;
    while(p!=S.base-1)
    {   
        printf("\t");
        printf(" %d ",*p);
        p--;
    }
    printf("\n");
}

9.判断栈是否为空

void IsNullStack(SqStack S)
{
    //判断栈是否为空
    if(S.base==S.top||S.base==NULL)
        printf("\t栈为空栈\n");
    else 
        printf("\t栈不为空\n");
}

10.获取栈顶元素

Status GetTop(SqStack S)
{   
    //获取栈顶元素
    int e;
    e=*(S.top-1);
    printf("\t栈顶元素为%d\n",e);
}

11.清空一个栈

void ClearStack(SqStack &S)
{   
    //清空一个栈    
    S.top=S.base;
}

12.摧毁一个栈

void DestroyStack(SqStack &S)
{  
    //摧毁一个栈
    free(S.base);
    S.base=S.top;
    S.stacksize=0;
    S.top=NULL;
    S.base=NULL;
}

13.switch功能语句

void swi(SqStack S){
        int num;
        program();
        printf("\t输入的元素是：");
    scanf("%d",&num);
    printf("\n\n");
    while(num)
    {   
        switch(num)
        {
            case 0:
                num=0;
            break;
            case 1:
                if(S.base==NULL){
                    printf("\t在进行操作1之前需要操作功能9\n");
                }else{
                    printf("\t判断栈是否为空\n");
                    IsNullStack(S);
                }
            break;
            case 2:
                if(S.base==NULL){
                    printf("\t在进行操作2之前需要操作功能9\n");
                }else{
                    printf("\t2.按栈弹出的顺序输出栈\n");
                    PrintStack_Pop(S);
                    }
            break;
            case 3:
                if(S.base==NULL){
                    printf("\t在进行操作3之前需要操作功能9\n");
                }else{
                    printf("\t3.按栈输入的顺序输出栈里面的值\n");
                    PrintStack_int(S);
                }
            break;
            case 4:
                if(S.base==NULL){
                    printf("\t在进行操作4之前需要操作功能9\n");
                }else{
                    printf("\t4.获取栈顶元素\n");
                    GetTop(S);
                }
            break;
            case 5:
                if(S.base==NULL){
                    printf("\t在进行操作5之前需要操作功能9\n");
                }else{
                    printf("\t5.摧毁一个栈\n");
                    DestroyStack(S);
                    printf("\t栈已经被摧毁\n");
                }
            break;
            case 6:
                    if(S.base==NULL){
                        printf("\t在进行操作6之前需要操作功能9\n");
                    }else{
                        printf("\t6.清空一个栈\n");
                        ClearStack(S);
                        printf("\t栈已经清空");
                    }
            break;
            case 7:
                    if(S.base==NULL){
                        printf("\t在进行操作7之前需要操作功能9\n");
                    }else{
                        printf("\t7.求栈的长度\n");
                        StackLength(S);
                    }
            break;
            case 8:
                    if(S.base==NULL){
                        printf("\t在进行操作8之前需要操作功能9\n");
                    }else{
                        printf("\t弹栈，并且返回出弹栈元素\n");
                        int a;
                        Pop(S,&a);
                        printf("\t8.弹栈弹出的元素是%d\n",a);
                    }
            break;
            case 9:
                printf("\t9.输入栈内数据\n");
                InputStack(S);
            break;
            case 10:
                if(S.base==NULL){
                    printf("\t在进行操作10之前需要操作功能9\n");
                }else{
                    printf("\t10.在清空的基础下重新建立栈\n");
                    DestroyStack(S);
                    printf("\t请重新输入栈内数据\n");
                    InputStack(S);
                }
                break;
            case 11:
                if(S.base==NULL){
                    printf("\t在进行操作11之前需要操作功能9\n");
                }else{
                    printf("\t11.在栈顶插入元素\n");
                    int x;
                    printf("\t请输入想要插入栈顶的元素:\n");
                    scanf("%d",&x);
                    Push(S,x);
                    printf("\t插入完成\n");
                }
            break;
            default:
                printf("输入有误，请重新输入\n");
        }
        printf("\n\n\n");
        program();
        printf("\t输入的元素是：");
        scanf("%d",&num);
        printf("\n\n");
    }
}

14.全部代码

//define区
#define Stack_Init_Size 100
#define Stack_Increment 10
#define OK 1
#define OVERFLOW -2
#define ERROR 0

//预处理指令区
#include<stdio.h>
#include<stdlib.h>

//typedef
typedef int Status;
typedef struct {
    int *base;
    int *top;
    int stacksize;
}SqStack;

Status InitStack(SqStack &S);       //建栈
SqStack InputStack(SqStack &S);     //输入栈内元素
Status Push(SqStack &S,int e);      //进栈
Status Pop(SqStack &S,int *e);      //弹栈，并且返回出弹栈元素
Status StackLength(SqStack S);      //栈内元素的个数
void PrintStack_int(SqStack S);     //按栈输入的顺序输出栈里面的值
void PrintStack_Pop(SqStack S);     //按弹栈顺序输出栈里面的值
void IsNullStack(SqStack S);        //判断是否为空栈
Status GetTop(SqStack S);           //获取栈顶元素
void ClearStack(SqStack &S);        //清空栈
void DestroyStack(SqStack &S);      //摧毁栈
void program();                     //功能函数
void swi(SqStack S);                //switch

int main()
{
    SqStack S;
    S.base=NULL;
    swi(S);
    printf("\t程序退出了，下次见\n");
}

Status InitStack(SqStack &S)
{
    //建栈
    S.base=(int*)malloc(Stack_Init_Size*sizeof(int));
    if(!S.base) exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=Stack_Init_Size;
    return OK;
}

SqStack InputStack(SqStack &S)
{   
    int a;
    /*scanf("%d",&a);
    while(a!=-1)
    {   
            if(S->top-S->base>S->stacksize)
            {
            S->base=(int *)realloc(S->base,(Stack_Init_Size+Stack_Increment)*sizeof(int));
            if(!S->base) printf("NoRealloc\n");
            S->top=S->base+S->stacksize;
            S->stacksize=S->stacksize+Stack_Increment;
            }
            *S->top++ = a;
            scanf("%d",&a);
    }*/
    InitStack(S);
    printf("\t");
    for(int i=0;;i++){
    scanf("%d",&a);
    if(a==-1)break;
    *S.top++ =a;
    }
    printf("\t写入完成\n");
}

Status Push(SqStack &S,int e)
{
    //进栈
    if(S.top-S.base>S.stacksize)
    {
        S.base=(int *)realloc(S.base,(Stack_Init_Size+Stack_Increment)*sizeof(int));
        if(!S.base) printf("NoRealloc\n");
        S.top=S.base+S.stacksize;
        S.stacksize=S.stacksize+Stack_Increment;
    }
    *S.top++=e;
    return OK;
}

Status Pop(SqStack &S,int *e)
{   
    //弹栈，并且返回出弹栈元素
    *e=*--S.top;
    return OK;
}

Status StackLength(SqStack S)
{   
    //栈长
    int Length=S.top-S.base;
    printf("\tlength = %d\n",Length);
    return Length;
}

void PrintStack_int(SqStack S)
{
    //按栈输入的顺序输出栈里面的值
    int *p=S.base;
    while(p!=S.top)
    {   
        printf("\t");
        printf(" %d ",*p);
        p++;
    }
    printf("\n");
}

void PrintStack_Pop(SqStack S)
{   
    //按栈弹出的顺序输出栈
    int *p=S.top-1;
    while(p!=S.base-1)
    {   
        printf("\t");
        printf(" %d ",*p);
        p--;
    }
    printf("\n");
}

void IsNullStack(SqStack S)
{
    //判断栈是否为空
    if(S.base==S.top||S.base==NULL)
        printf("\t栈为空栈\n");
    else 
        printf("\t栈不为空\n");
}

Status GetTop(SqStack S)
{   
    //获取栈顶元素
    int e;
    e=*(S.top-1);
    printf("\t栈顶元素为%d\n",e);
}

void ClearStack(SqStack &S)
{   
    //清空一个栈    
    S.top=S.base;
}

void DestroyStack(SqStack &S)
{  
    //摧毁一个栈
    free(S.base);
    S.base=S.top;
    S.stacksize=0;
    S.top=NULL;
    S.base=NULL;
} 

void program()
{
    printf("\t请输入以下功能数字\n");
    printf("\t0.退出\n");
    printf("\t1.判断栈是否为空\n");
    printf("\t2.按栈弹出的顺序输出栈\n");
    printf("\t3.按栈输入的顺序输出栈里面的值\n");
    printf("\t4.获取栈顶元素\n");
    printf("\t5.摧毁一个栈\n");
    printf("\t6.清空一个栈\n");
    printf("\t7.求栈的长度\n");
    printf("\t8.弹栈，并且返回出弹栈元素\n");
    printf("\t9.输入栈内数据\n");
    printf("\t10.在清空的基础下重新建立栈\n");
    printf("\t11.请输入想要插入栈顶的元素\n");

}

void swi(SqStack S){
        int num;
        program();
        printf("\t输入的元素是：");
    scanf("%d",&num);
    printf("\n\n");
    while(num)
    {   
        switch(num)
        {
            case 0:
                num=0;
            break;
            case 1:
                if(S.base==NULL){
                    printf("\t在进行操作1之前需要操作功能9\n");
                }else{
                    printf("\t判断栈是否为空\n");
                    IsNullStack(S);
                }
            break;
            case 2:
                if(S.base==NULL){
                    printf("\t在进行操作2之前需要操作功能9\n");
                }else{
                    printf("\t2.按栈弹出的顺序输出栈\n");
                    PrintStack_Pop(S);
                    }
            break;
            case 3:
                if(S.base==NULL){
                    printf("\t在进行操作3之前需要操作功能9\n");
                }else{
                    printf("\t3.按栈输入的顺序输出栈里面的值\n");
                    PrintStack_int(S);
                }
            break;
            case 4:
                if(S.base==NULL){
                    printf("\t在进行操作4之前需要操作功能9\n");
                }else{
                    printf("\t4.获取栈顶元素\n");
                    GetTop(S);
                }
            break;
            case 5:
                if(S.base==NULL){
                    printf("\t在进行操作5之前需要操作功能9\n");
                }else{
                    printf("\t5.摧毁一个栈\n");
                    DestroyStack(S);
                    printf("\t栈已经被摧毁\n");
                }
            break;
            case 6:
                    if(S.base==NULL){
                        printf("\t在进行操作6之前需要操作功能9\n");
                    }else{
                        printf("\t6.清空一个栈\n");
                        ClearStack(S);
                        printf("\t栈已经清空");
                    }
            break;
            case 7:
                    if(S.base==NULL){
                        printf("\t在进行操作7之前需要操作功能9\n");
                    }else{
                        printf("\t7.求栈的长度\n");
                        StackLength(S);
                    }
            break;
            case 8:
                    if(S.base==NULL){
                        printf("\t在进行操作8之前需要操作功能9\n");
                    }else{
                        printf("\t弹栈，并且返回出弹栈元素\n");
                        int a;
                        Pop(S,&a);
                        printf("\t8.弹栈弹出的元素是%d\n",a);
                    }
            break;
            case 9:
                printf("\t9.输入栈内数据\n");
                InputStack(S);
            break;
            case 10:
                if(S.base==NULL){
                    printf("\t在进行操作10之前需要操作功能9\n");
                }else{
                    printf("\t10.在清空的基础下重新建立栈\n");
                    DestroyStack(S);
                    printf("\t请重新输入栈内数据\n");
                    InputStack(S);
                }
                break;
            case 11:
                if(S.base==NULL){
                    printf("\t在进行操作11之前需要操作功能9\n");
                }else{
                    printf("\t11.在栈顶插入元素\n");
                    int x;
                    printf("\t请输入想要插入栈顶的元素:\n");
                    scanf("%d",&x);
                    Push(S,x);
                    printf("\t插入完成\n");
                }
            break;
            default:
                printf("输入有误，请重新输入\n");
        }
        printf("\n\n\n");
        program();
        printf("\t输入的元素是：");
        scanf("%d",&num);
        printf("\n\n");
    }
}

15.运行结果

在没有建立栈的条件下如果输入别的数据

 1.建栈

2.按栈弹出的顺序输出栈

 3.按栈输入的顺序输出栈里面的值

 4.获取栈顶元素

7.求栈的长度

 8.弹栈，并且返回出弹栈元素

验证：

 11.请输入想要插入栈顶的元素

6.清空

验证：

 

10.在清空的状态下重新输入栈

验证：

5.摧毁栈

 

0.退出

 

 

 

 

 

 

 

 

M DownTime
关注
  • 24
    点赞
  • 踩
  • 245
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
栈的基本操作
青耕_的博客
02-14 944
栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
栈的操作
qq_45243872的博客
10-31 106
1、实例化 ```java Stack stack = new Stack(); 2、进栈 stack.push(Object);//返回的是入栈的内容 stack.add(Object);//返回的是true或false 3、出栈 stack.pop();//输出并删除栈顶元素 stack.peek();//输出不删除栈顶元素 4、判断是否为空 stack.isEmpty(); 5、输出栈（[ , , , …]) System.out.println(stack); 6、查看某
【数据结构与算法（C 语言）】栈的基本操作函数（动图演示） 及 栈的实际应用之一：进制转换
最新发布
weiweiliude2的专栏
05-31 946
数据结构与算法 栈
实验3：顺序栈的基本操作
zsl20200217的博客
04-23 1968
实验3：顺序栈的基本操作 实验目的： 1、掌握顺序栈的存储结构 2、实现顺序栈的基本操作 实验内容： 判断一个表达式中括号“（”与“）”、“[”与“]”、“{”与“}”是否匹配。若匹配，则返回1；否则返回0。 实验数据： {(1+2/[3])} {[}]2+4() 实验要求： 代码完整 程序的运行结果 实验心得（实验收获，不足）： 提示： 本实验是在顺序栈的基本上完成的，请写出顺序栈的定义和关于顺序栈的七种操作。 再写上int Match(ElemType *exps)函数。
栈的基本操作--c语言
EGALong的博客
06-25 655
栈的相关操作
【数据结构】栈的操作
qq_25218219的博客
10-13 750
栈 定义：栈是限定仅在表尾进行插入或删除操作的线性表。 由于栈只有一边开口存取数据，称开口的那一端为“栈顶”，封死的那一端为“栈底”（类似于盛水的木桶，从哪进去的最后还得从哪出来）。 栈操作数据元素的方法 栈操作数据元素只有两种动作： 入栈：在栈顶插入一个元素的操作； 出栈：从栈顶删除一个元素的操作； 栈的“先进后出”原则（Last In First Out） 使用栈存储数据元素，对数据元素的“存”和“取”有严格的规定：数据按一定的顺序存储到栈中，当需要调取栈中某数据元素时，需要将在该数据元素之后
C语言栈基本操作
qq_27638851的博客
08-22 683
【代码】C语言顺序栈基本操作。
顺序栈基本操作
03-04
数据结构 顺序栈基本操作
顺序栈基本操作.cpp
11-21
初学数据结构，不是很熟悉，大家一起共同学习，多交流一下，顺序栈基本操作，如有错误请大家多多指教，我会及时更正
链式栈的基本操作
12-12
一个链式栈的类，实现了栈的基本操作，入栈，出栈，清空，复制（拷贝构造函数）
栈的基本操作（出栈、入栈、销毁...
m0_73726899的博客
03-20 1475
可以类比一个“羽毛球筒”，最先进入的羽毛球，必须等待，其他球取出，才能出来。第一种，top = 0，则栈顶元素在 top - 1 的位置。空间开辟的规则，一般遵循，一开始开辟四个单位。第二种，top = -1，则栈顶元素在 top 的位置。使用完毕后，也必须使用free函数，释放掉。需要对栈的空间进行扩容，使用realloc函数。，其只允许在固定的一端进行插入和删除元素操作。后面扩容时，扩增为原来的2倍。创建栈的结构体，包括栈的基本信息，本篇文章就到此结束啦！以下就是全篇汇总啦~
【C语言】二十二步了解函数栈帧(压栈、传参、返回、弹栈)
iluo12的博客
02-09 5691
22步理解什么是函数栈帧！
微机原理 18-堆栈操作指令
热门推荐
imxlw00的专栏
02-22 1万+
堆栈是按照LIFO原则组织的一段内存区域。(“先进后出”,或说“后进先出” ） 80X86规定堆栈设置在堆栈段内。用SS段寄存器记录其段地址 用SP始终指向堆栈的顶部。 栈顶：堆栈的顶部。即最后推入堆栈的信息所在的单元。 栈顶随着数据出栈、入栈而变化。 生长方向：栈顶的变化方向。分向下生长和向上生长两种。 8086中的堆栈是向下生长的。即栈顶向地址码小的方向生长。 ...
个人笔记--栈的基本操作（初始化，出栈，入栈以及进制转换）
Lzh4792的博客
10-28 9775
栈的一些基本操作 目录栈的一些基本操作栈的概念(新手必看)初始化栈销毁栈清空栈判空栈栈长度取栈顶元素入栈操作出栈操作输出栈进制转换 栈的概念(新手必看) 栈（stack）又名堆栈，是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作入栈，就是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈，它是把栈顶元素删除掉，使前一个元素成为新的栈顶元素。 存在两个指针，一个始终指向栈底，叫做栈底指针，一个指向栈顶
关于栈的创建以及基本操作（c语言）
m0_64028711的博客
04-11 3582
最近在网上寻找了不少关于栈的知识，由此特来记录本人的一些心得。 栈和表一样，分为顺序栈和链栈，我们先来讲简单的顺序栈。 顺序栈其实和顺序表差别不大，以下是顺序栈的创建： #include<stdio.h> #include<stdlib.h> #define max 100 typedef struct Tack{ int *data; int top; }Tack; 创建好后就得初始化； void inTack(Tack *s) {
数据结构实验之栈与队列八：栈的基本操作
Horizonhui
09-27 1001
数据结构实验之栈与队列八：栈的基本操作 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 堆栈是一种基本的数据结构。堆栈具有两种基本操作方式，push 和 pop。push一个值会将其压入栈顶，而 pop 则会将栈顶的值弹出。现在我们就来验证一下堆栈的使用。
栈的压入.弹出操作
weixin_46009158的博客
05-01 669
题目: 思路: 先遍历将pushA里的元素入栈 当栈不为空,且栈顶元素与popA中元素相等时,将栈顶元素出栈,再比较popA的下一个元素和新的栈顶元素 当pushA里的元素遍历结束,且辅助栈中元素为空,则代表true反之false 代码: //栈的压入弹出序列 public boolean IsPopOrder(int [] pushA,int [] popA) { ...
c语言链式栈基本操作
11-07
链式栈是一种基于链表实现的栈结构，它的基本操作包括入栈、出栈、获取栈顶元素和判断栈是否为空。下面是C语言链式栈的基本操作： 1. 定义链式栈的结构体 ```c typedef struct Node { int data; struct Node* next; } Node; typedef struct Stack { Node* top; } Stack; ``` 2. 初始化链式栈 ```c void initStack(Stack* stack) { stack->top = NULL; } ``` 3. 判断链式栈是否为空 ```c int isEmpty(Stack* stack) { return stack->top == NULL; } ``` 4. 入栈操作 ```c void push(Stack* stack, int data) { Node* node = (Node*)malloc(sizeof(Node)); node->data = data; node->next = stack->top; stack->top = node; } ``` 5. 出栈操作 ```c int pop(Stack* stack) { if (isEmpty(stack)) { printf("Stack is empty.\n"); return -1; } int data = stack->top->data; Node* temp = stack->top; stack->top = stack->top->next; free(temp); return data; } ``` 6. 获取栈顶元素 ```c int getTop(Stack* stack) { if (isEmpty(stack)) { printf("Stack is empty.\n"); return -1; } return stack->top->data; } ``` 以上就是C语言链式栈的基本操作。需要注意的是，链式栈的入栈和出栈操作都是在链表的头部进行的，因此时间复杂度为O(1)。如果需要遍历整个链表，时间复杂度为O(n)。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值