数据结构C语言-顺序栈、共享栈、链栈的定义、销毁及出入栈操作

原创 已于 2022-06-27 21:21:19 修改 · 1.5k 阅读 · 14 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
数据结构学习

当前文章被收录于：

数据结构学习
5 篇文章 0 人学习
订阅专栏 查看详情
于 2022-06-12 21:38:55 首次发布
这篇博客详细介绍了如何使用C语言实现顺序栈、共享栈和链栈的数据结构，包括创建、销毁、入栈、出栈、读取栈顶元素以及判断栈是否为空的操作。内容涵盖了各个栈的函数定义和具体实现，是理解栈操作的实用参考资料。

目录

顺序栈声明部分：

每个函数的具体定义：

共享栈声明部分：

 每个函数的具体定义：

 链栈声明部分：

 每个函数的具体定义： 

顺序栈声明部分：

#define MAX_SIZE 10

typedef struct
{
    int data[MAX_SIZE];
    int top; //栈顶指针（栈顶元素数组下标,空栈为-1）
} SqStack;   // SqStack 顺序栈

SqStack CreateStack();            //创建顺序栈
int Push(SqStack *S, int elem);   //进栈
int Pop(SqStack *S, int *temp);   //出栈，并用temp带出
int GetTop(SqStack S, int *temp); //读取栈顶元素，并用temp带出
int StackIsEmpty(SqStack S);      //判空：=1为空栈，=0为非空栈

每个函数的具体定义：

创建顺序栈：

SqStack CreateStack()
{
    SqStack S;
    S.top = -1;
    return S;
}

进栈：

int Push(SqStack *S, int elem)
{
    if (S->top == MAX_SIZE - 1)
    {
        printf("栈满，入栈失败\n");
        return 0;
    }

    S->top++;
    S->data[S->top] = elem;
    return 1;
}

出栈（并用temp带出出栈元素的值）：

int Pop(SqStack *S, int *temp)
{
    if (S->top == -1)
    {
        printf("栈空，出栈失败\n");
        return 0;
    }

    *temp = S->data[S->top];
    S->top--;
    return 1;
}

读取栈顶元素，并用temp带出：

int GetTop(SqStack S, int *temp)
{
    if (S.top == -1)
    {
        printf("栈空，查询失败\n");
        return 0;
    }

    *temp = S.data[S.top];
    return 1;
}

 判空（=1为空栈，=0为非空栈）：

int StackIsEmpty(SqStack S)
{
    return S.top == -1;
}

共享栈声明部分：

typedef struct
{
    int data[MAX_SIZE];
    int top1, top2; //1,2号栈顶指针,1号自底向上，2号自顶向下
} ShStack;          //ShStack 共享栈

ShStack CreateShStack();                       //创建共享栈
int ShPush(ShStack *S, int stack, int elem);   //elem进stack号栈
int ShPop(ShStack *S, int stack, int *temp);   //stack号栈出栈，并用temp带出
int ShGetTop(ShStack S, int stack, int *temp); //得到stack的顶指针指向的元素
int ShStackIsEmpty(ShStack S);                 //判空：=1为空栈，=0为非空栈
int ShStackIsFull(ShStack S);                  //判满: =1为满栈，=0为非满栈

 每个函数的具体定义：

创建共享栈：

ShStack CreateShStack()
{
    ShStack S;
    S.top1 = -1;
    S.top2 = MAX_SIZE;
    return S;
}

入栈（elem进stack号栈）：

int ShPush(ShStack *S, int stack, int elem)
{
    if (stack != 1 && stack != 2)
    {
        printf("输入的栈非法，插入失败\n");
        return 0;
    }
    if (S->top1 + 1 == S->top2)
    {
        printf("栈满，入栈失败\n");
        return 0;
    }

    if (stack == 1)
    {
        S->top1++;
        S->data[S->top1] = elem;
    }
    else
    {
        S->top2--;
        S->data[S->top2] = elem;
    }
    return 1;
}

出栈（stack号栈出栈，并用temp带出）：

int ShPop(ShStack *S, int stack, int *temp)
{
    if (stack != 1 && stack != 2)
    {
        printf("输入的栈非法，入栈失败\n");
        return 0;
    }
    if (stack == 1)
    {
        if (S->top1 == -1)
        {
            printf("1号栈空，出栈失败\n");
            return 0;
        }
        *temp = S->data[S->top1];
        S->top1--;
    }
    else
    {
        if (S->top2 == MAX_SIZE)
        {
            printf("2号栈空，出栈失败\n");
            return 0;
        }
        *temp = S->data[S->top2];
        S->top2++;
    }
    return 1;
}

得到stack的顶指针指向的元素的值： 

int ShGetTop(ShStack S, int stack, int *temp)
{
    if (stack != 1 && stack != 2)
    {
        printf("输入的栈非法，入栈失败\n");
        return 0;
    }
    if (stack == 1)
    {
        if (S.top1 == -1)
        {
            printf("1号栈空，出栈失败\n");
            return 0;
        }
        *temp = S.data[S.top1];
    }
    else
    {
        if (S.top2 == MAX_SIZE)
        {
            printf("2号栈空，出栈失败\n");
            return 0;
        }
        *temp = S.data[S.top2];
    }
    return 1;
}

 判空（=1为空栈，=0为非空栈）与   判满（=1为满栈，=0为非满栈）：

int ShStackIsEmpty(ShStack S) //判空
{
    return (S.top1 == -1 && S.top2 == MAX_SIZE);
}

int ShStackIsFull(ShStack S) //判满
{
    return (S.top1 + 1 == S.top2);
}

 链栈声明部分(带头结点)：

typedef struct Linode
{
    int data;
    struct Linode *next; //用单链表结点定义栈元素
} Linode, *LiStack;      // LiStack 链栈,通过对头结点后继节点的插入删除实现出入栈

//以下链栈为带头结点的链栈
LiStack CreateLiStack();            //创建链栈
void DestoryLiStack(LiStack *L);    //销毁链栈
int LiPush(LiStack L, int elem);    //通过单链表头插法入栈
int LiPop(LiStack L, int *temp);    //通过单链表后删头结点的后继结点操作出栈
int LiGetTop(LiStack L, int *temp); //读取栈顶元素，并用temp带出
int LiStackIsEmpty(LiStack L);      //判空：=1为空栈，=0为非空栈

#endif

 每个函数的具体定义： 

创建链栈：

LiStack CreateLiStack()
{
    LiStack L = (Linode *)malloc(sizeof(Linode));
    L->data = 0;
    L->next = NULL;
    return L;
}

 销毁链栈：

void DestoryLiStack(LiStack *L)
{
    Linode *p = NULL;
    while ((*L))
    {
        p = *L;
        (*L) = (*L)->next;
        free(p);
    }
}

通过单链表头插法入栈：

int LiPush(LiStack L, int elem)
{
    if (L == NULL) 
    {
        printf("输入的栈非法，入栈失败\n");
        return 0;
    }

    Linode *new = (Linode *)malloc(sizeof(Linode));
    if (new == NULL)
    {
        printf("内存不足，无法入栈");
        return 0;
    }

    new->data = elem;
    new->next = L->next;
    L->next = new;
    return 1;
}

 通过单链表后删头结点的后继结点操作出栈：

int LiPop(LiStack L, int *temp)
{
    if (L == NULL)
    {
        printf("输入的栈非法，入栈失败\n");
        return 0;
    }

    Linode *p = L->next;
    if (p == NULL)
    {
        printf("空栈，无元素可出栈\n");
        return 0;
    }
    *temp = p->data;
    L->next = p->next;
    free(p);
    return 1;
}

读取栈顶元素，并用temp带出：

int LiGetTop(LiStack L, int *temp)
{
    if (L == NULL) 
    {
        printf("输入的栈非法，入栈失败\n");
        return 0;
    }
    if (L->next == NULL)
    {
        printf("空栈，无元素\n");
        return 0;
    }
    else
    {
        *temp = L->next->data;
    }
    return 1;
}

判空（=1为空栈，=0为非空栈）：

int LiStackIsEmpty(LiStack L)
{
    return (L->next == NULL);
}

 链栈声明部分(带头结点)：

typedef struct Linode
{
    int data;
    struct Linode *next; //用单链表结点定义栈元素
} Linode, *LiStack;      // LiStack 链栈

//以下操作为不带头结点的链栈
LiStack CreateNHLiStack();            //创建链栈
void DestoryHNLiStack(LiStack *L);    //销毁链栈
int NHLiPush(LiStack *L, int elem);   //通过单链表头插法入栈
int NHLiPop(LiStack *L, int *temp);   //通过单链表后删后继结点操作出栈
int NHLiGetTop(LiStack L, int *temp); //读取栈顶元素，并用temp带出
int NHLiStackIsEmpty(LiStack L);      //判空：=1为空栈，=0为非空栈

 每个函数的具体定义： 

创建链栈：

LiStack CreateNHLiStack()
{
    LiStack L;
    return L;
}

  销毁链栈：

void DestoryHNLiStack(LiStack *L)
{
    Linode *p = NULL;
    while ((*L))
    {
        p = *L;
        (*L) = (*L)->next;
        free(p);
    }
}

 通过单链表头插法入栈：

int NHLiPush(LiStack *L, int elem)
{
    Linode *new = (Linode *)malloc(sizeof(Linode));
    if (new == NULL)
        {
            printf("内存不足，无法入栈");
            return 0;
        }

    new->data = elem;
    if ((*L) == NULL)
    {
        new->next = NULL;
    }
    else
    {
        new->next = (*L);
    }
    (*L) = new;

    return 1;
}

通过单链表后删后继结点操作出栈： 

int NHLiPop(LiStack *L, int *temp)
{
    if ((*L) == NULL)
    {
        printf("输入的栈非法或无元素，出栈失败\n");
        return 0;
    }

    Linode *p = (*L);
    *temp = (*L)->data;
    (*L) = (*L)->next;
    free(p);
    return 1;
}

 读取栈顶元素，并用temp带出：

int NHLiGetTop(LiStack L, int *temp)
{
    if (L == NULL)
    {
        printf("输入的栈非法或无元素，出栈失败\n");
        return 0;
    }
    *temp = L->data;
    return 1;
}

 判空（=1为空栈，=0为非空栈）：

int NHLiStackIsEmpty(LiStack L)
{
    return L == NULL;
}

个人代码，如有误请指出。

标签
#数据结构 #c语言 #排序算法
链栈（带头结点和不带头结点）——建立、初始化、判空、入栈、出栈、读栈顶、销毁等操作（王道版）
a1833235073的博客
07-23 4520
链栈（带头结点和不带头结点）——建立、初始化、判空、入栈、出栈、读栈顶、销毁等操作（王道版）
【数据结构入门】栈（Stack）的实现（定义、销毁、入栈、出栈等） | 图解数据结构，超详细哦~
codewinter的博客
09-11 7328
文章目录（1）前言1）栈的概念2）进栈出栈的形式3）栈的存储结构（2）栈的实现（顺序栈）1）栈的定义2）栈的初始化3）栈的销毁4）入栈5）出栈6）检测栈是否为空7）获取栈中有效元素个数8）获取栈顶元素（3）测试栈的功能 数据结构系列文章： 【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改） 【数据结构入门】无头单向非循环链表（SList）详解（定义、增、删、查、改） | 图解链表，超生动详细哦~ 【数据结构入门】带头双向循环链表（List）详解（定义、增、删、查、改） | 配有大量图解，
[数据结构]c语言实现链栈的入栈，出栈，清空，销毁等操作
热门推荐
最暖一天
10-04 2万+
最近在学习数据结构中的栈，于是在此记录一下栈的抽象数据类型/* 栈的抽象数据类型 ADT 栈(stack) Data 同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系 Operation InitStack(*S)：初始化操作，建立一个空栈S DestroyStack(*S):若栈存在，则销毁它 ClearStack(*S):将栈清空 StackEmp
数据结构 学习笔记 栈
Sensente的博客
10-18 639
首先明确，栈和队列 是特殊的线性表。 栈(STL : STACK) 一、定义 栈是只能在一端进行插入和删除操作的线性表 日常例子： 洗碗摞一堆； 书摞成一堆； 一些枪支子弹夹中子弹的操作方式等。 1.1一些基本概念 栈顶(top) 进行插入和删除操作的一端 栈底(bottom) 相对栈顶的另一端 入栈(push) 插入操作 出栈(pop) 出栈操作 空栈：无元素的栈 ...
链栈的基本操作（初始化，出栈，入栈，清空，销毁，取栈顶元素，遍历）
m0_62673405的博客
11-22 4184
#include "stdio.h" #include "stdlib.h" int Max_SIZE=100; typedef struct LinkStackNode { int data; LinkStackNode *next; }LinkStackNode; typedef struct LinkStack { LinkStackNode *top; int length; }LinkStack; LinkStack *initialize_stack()//链栈...
【数据结构】栈的知识点总结--关于栈的定义和基本操作；C语言实现栈；顺序栈；链栈；共享栈；栈的易错点的总结
小人物，大梦想！
09-11 3003
关于栈的定义和基本操作；C语言实现栈；顺序栈；链栈；共享栈；栈的易错点的总结
【数据结构】C语言实现链栈
蒙奇D索大的博客
01-18 2526
【数据结构】第三章——栈、队列与数组 详细介绍通过C语言实现链栈
【数据结构】C语言实现共享栈
蒙奇D索大的博客
01-15 3926
【数据结构】第三章——栈、队列与数组 详细介绍通过C语言实现共享栈
C语言 栈(顺序栈、链栈、共享栈）
m0_73070900的博客
04-14 2742
栈初始化、进栈、出栈等基本操作算法实现。以上就是顺序栈、链式栈和共享栈，本文仅仅简单介绍了栈的基本操作，而栈的运用十分灵活。
栈之顺序栈（包含完整代码）C语言版
weixin_44918193的博客
07-07 1万+
看一下关于栈的思维导图 栈是只允许在一端进行插入或删除操作的线性表，按照物理结构的不同，栈又分为顺序栈和链栈。 本篇文章是顺序栈的专场。 来看实现各个功能的代码块 //顺序栈的定义 #define MaxSize 10 //定义栈中最大元素的个数 typedef struct{ elemtype data[MaxSize]; //静态数组存放栈中元素，销毁栈时不必手动释放空间 int top; //定义栈顶指针 }SqStack; //初始化栈 void InitStack(SqStack &
栈（Stack）顺序栈以及链栈的相关操作（C语言）
派拉斯兔子的博客
05-07 1568
<img src='https://img-blog.csdnimg.cn/2021050719043789.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDk2Njcw,size_16,color_FFFFFF'>
【数据结构与算法】走进数据结构的“时间胶囊”——栈
2401_85548793的博客
10-22 1251
栈（Stack）是一种只允许在一端进行插入或删除的线性表。这端被称为栈顶（Top），另一端则被称为栈底（Bottom）。栈遵循后进先出（Last In First Out，LIFO）的原则，即最后插入的元素会第一个被删除。首先，我们定义了一个名为STDataType的类型别名，它基于int类型。这个类型别名将用于栈中存储的数据元素。接着，我们定义了一个名为Stack的结构体（通过typedef，我们也可以用ST来引用它）。arr：这是一个指向STDataType类型的指针。
数据结构3-栈的知识点整理
渐渐的忘记，赶不上明天（读研ing，2024年毕业）
05-07 3429
文章目录1. 栈的定义和基本操作1.1 栈的定义1.2 栈的基本操作1.3 栈的分类1.4 小结2. 静态顺序栈2.1 基本操作2.1.1 初始化操作以及判断栈是否为空2.1.2 进栈操作2.1.3 出栈操作2.1.4 读取栈顶元素2.2 栈的两种实现2.3 共享栈2.4 小结3. 动态链栈3.1 基本操作3.1.1 初始化操作3.1.2 往链栈顶添加元素3.1.3 链栈顶弹出元素3.1.4 查看...
顺序栈的基本操作
fatherofli的博客
05-08 2493
栈的定义： 栈是限定仅在表尾进行插入和删除操作的线性表，其特点是先进后出，且仅在栈顶进行操作。所以在很多算法或应用中（例如在网页中的后退），在需要用到“先进后出的思想”时，我们可以考虑用栈来实现。 摘自《大话数据结构》 栈的存储结构： 栈的存储方式分为顺序栈和链栈， 顺序栈中用一些地址连续的存储单元来存放数据，类似于数组的形式，顺序栈的存储密度高，但由于需要提前设置好栈的大小，因此容易浪费空间。 链栈采用链状结构进行存储，在形式上类似于链表，栈链便于多个栈共享存储空间和提高其效率，且不存在栈满上溢的情
栈与队列Part1--栈的定义与应用、顺序栈、两栈共享空间、链栈的部分操作具体实现（C语言描述）
ZZay's
06-28 673
栈的定义、抽象数据类型(ADT)、顺序存储结构定义、两栈共享空间定义及进栈出栈操作具体实现方法（C语言描述） 此文章仅作为自己学习过程中的记录和总结，同时会有意地去用英文来做笔记，一些术语的英译不太准确，内容如有错漏也请多指教，谢谢！ 一、栈(Stack)的定义: 栈(Stack): 是限定仅在表尾进行插入和删除操作的线性表。是一种特殊的线性表。 栈又称为 后进先出(Last In First Out) 的线性表，简称LIFO结构。 （Examples：Photoshop and Word’s “Un
数据结构精讲：从栈的定义到链式实现，再到LeetCode实战
dongaoran的博客
11-11 1263
栈，这个看似简单的数据结构，却是计算机科学中最基础、最重要的概念之一，希望这篇博客能帮助你建立起对栈的系统化认知，并激发你进一步探索数据结构的兴趣。
【数据结构】 栈与队列之顺序栈（Stack）「详解」
最新发布
2503_94545876的博客
02-02 1112
摘要：本文系统介绍了栈的基本概念、操作及实现方式。栈是遵循LIFO原则的线性表，支持入栈(Push)和出栈(Pop)操作。详细讲解了顺序栈的实现方法，包括结构定义、初始化、清空、判空、获取栈顶元素等核心操作。特别介绍了双栈共享空间的优化方案，通过让两个栈分别从数组两端向中间延伸来提高空间利用率。最后指出这种结构适用于两个栈空间需求呈反向变化的情况，并预告后续将介绍链式存储的栈结构。
栈相关习题及详解(选择题和综合题) ——数据结构
Amour
10-26 1万+
栈的基本概念栈的定义栈：只允许在一端进行插入或删除操作的线性表。首先栈是一种线性表，但是限定这种线性表只能在某一端进行插入和删除操作。栈顶：线性表允许进行插入和删除的那一端 栈底：固定的，不允许进行插入和删除的另一端 空栈：不含任何元素的空表。进栈出栈的变化形式最先进栈的元素，是不是就只能是最后出栈呢答案是不一定，要看什么情况。栈对线性表的插入和删除的位置进行了限制，并没有对元素进出的时间进行限
《数据结构(C语言版)》学习笔记03 栈与队列
梦想终会实现
09-02 1272
栈与队列，包含顺序栈、链栈、顺序队列、链队列，并且涉及不同的初始条件和有无头结点的实现方法介绍。最后分析栈应用中的括号匹配和中缀后缀表达式相关算法和思路。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值