【C 数据结构】栈

最新推荐文章于 2024-04-27 18:02:39 发布
最新推荐文章于 2024-04-27 18:02:39 发布
阅读量801 收藏 28
点赞数 13
分类专栏： 数据结构 文章标签： c语言 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44431690/article/details/137766559
版权

文章目录

【 1. 基本原理 】

  • 栈（Stack） 是一个线性的数据结构：
    • 栈只能从表的一端存取数据，另一端是封闭的；
    • 在栈中，无论是存数据还是取数据，都必须遵循"先进后出"的原则，即最先进栈的元素最后出栈。
      在这里插入图片描述
  • 栈的开口端被称为 栈顶，栈顶元素指的就是距离栈顶最近的元素；封口端被称为 栈底，栈底元素指的是位于栈最底部的元素。
    在这里插入图片描述
  • 栈的的应用
    • 网页的返回。
    • 代码中的括号匹配。
    • 进制转换。

栈的分类

  • 栈分为数组栈和链表栈：
    • 顺序栈（数组栈） 采用顺序存储结构，使用数组进行功能的模拟，实现较为快速和便利。
    • 链表栈（链栈） 采用链式存储结构，实现较为麻烦，但是其稳定不易出错。在链表栈中又分为静态链表栈 和 动态链表栈：
      • 静态链表栈 给定栈的空间大小，不允许超过存储超过给定数据大小的元素。
      • 动态链表栈 使用的是 自动创建空间 的方法进行创建，只要符合机器的硬件要求以及编译器的控制，其理论上是极大的。

【 2. 动态链表栈 】

  • 我们以链表栈的动态链表栈为例子，进行栈的设计，在后文直接以栈一名字称呼动态链表栈，这也是各类语言标准模板中栈的实现方式。
    在这里插入图片描述

2.1 双结构体实现

2.1.0 栈的节点设计

  • 我们可以设计出两个结构体：
    • 一个结构体Node表示结点，其中包含有一个data域和next指针。其中data表示数据，其可以是简单的类型（如int,double等等），也可以是复杂的结构体（struct类型）；next指针表示，下一个的指针，其指向下一个结点，通过next指针将各个结点链接。
      在这里插入图片描述
    • 额外添加的另一个结构体，其包括了一个永远指向栈头的指针top和一个计数器count记录元素个数，（也可以设计成一个指针top和一个指针bottom分别指向栈头和栈尾）其主要功效就是设定允许操作元素的指针以及确定栈何时为空（count的方法是当count为0时为空，top和bottom方法就是两者指向同一个空间时为栈为空）。
      在这里插入图片描述
  • 采用的 top 和 count 组合的方法，C 实现：
//栈的结点设计
//单个结点设计，数据和下一个指针
typedef struct node     
{
    int data; 
    struct node *next;
} Node;
//利用上面的结点创建栈，分为指向头结点的top指针和计数用的count
typedef struct stack    
{
    Node *top;
    int count;
} Link_Stack;

2.1.1 入栈

  • 入栈(push)操作时，我们只需要找到top所指向的空间，创建一个新的结点，将新的结点的next指针指向我们的top指针指向的空间，再将top指针转移，指向新的结点，即是入栈操作。
    在这里插入图片描述
  • C 实现：
//入栈 push
Link_Stack *Push_stack(Link_Stack *p, int elem)
{
    if (p == NULL)
        return NULL;
    Node *temp;
    temp=(Node*)malloc(sizeof(Node));
    temp->data = elem;
    temp->next = p->top;
    p->top = temp;
    p->count++;
    return p;
}

2.1.2 出栈

  • 出栈（pop）操作，是在栈不为空的情况下（注意一定要进行判空操作），将栈顶的元素删除，同时top指针，next向下进行移动即可的操作。
    在这里插入图片描述
  • C 实现：
//出栈 pop
Link_Stack *Pop_stack(Link_Stack *p)
{
    Node *temp;
    temp = p->top;
    if (p->top == NULL)
    {
        printf("错误：栈为空");
        return p;
    }
    else
    {
        p->top = p->top->next;
        free(temp);
        p->count--;
        return p;
    }
}

2.1.3 遍历

  • 栈的遍历，由于栈的特殊性质，其只允许在一端进行操作，所以我们的遍历操作永远都是逆序的，其过程为：在栈不为空的情况下，一次从栈顶元素向下访问，直到指针指向空（即到栈尾）为结束。
  • C 实现：
//遍历栈：输出栈中所有元素
int show_stack(Link_Stack *p)
{
    Node *temp;
    temp = p->top;
    if (p->top == NULL)
    {
        printf("");
        printf("错误：栈为空");
        return 0;
    }
    while (temp != NULL)
    {
        printf("%d\t", temp->data);
        temp = temp->next;
    }
    printf("\n");
    return 0;
}

2.1.4 实例

  • C 实现：
#include <stdio.h>
#include <stdlib.h>
//栈的结点设计
//单个结点设计，数据和下一个指针
typedef struct node     
{
    int data; 
    struct node *next;
} Node;
//利用上面的结点创建栈，分为指向头结点的top指针和计数用的count
typedef struct stack    
{
    Node *top;
    int count;
} Link_Stack;
 
//创建栈
Link_Stack *Creat_stack()
{
    Link_Stack *p;
    //p = new Link_Stack;
    p=(Link_Stack*)malloc(sizeof(Link_Stack));
    if(p==NULL){
        printf("创建失败，即将退出程序");
        exit(0);
    }
    p->count = 0;
    p->top = NULL;
    return p;
}
 
//入栈 push
Link_Stack *Push_stack(Link_Stack *p, int elem)
{
    if (p == NULL)
        return NULL;
    Node *temp;
    temp=(Node*)malloc(sizeof(Node));
    //temp = new Node;
    temp->data = elem;
    temp->next = p->top;
    p->top = temp;
    p->count++;
    return p;
}
 
//出栈 pop
Link_Stack *Pop_stack(Link_Stack *p)
{
    Node *temp;
    temp = p->top;
    if (p->top == NULL)
    {
        printf("错误：栈为空");
        return p;
    }
    else
    {
        p->top = p->top->next;
        free(temp);
        //delete temp;
        p->count--;
        return p;
    }
}
 
//遍历栈：输出栈中所有元素
int show_stack(Link_Stack *p)
{
    Node *temp;
    temp = p->top;
    if (p->top == NULL)
    {
        printf("");
        printf("错误：栈为空");
        return 0;
    }
    while (temp != NULL)
    {
        printf("%d\t", temp->data);
        temp = temp->next;
    }
    printf("\n");
    return 0;
}
 
int main()
{ //用主函数测试一下功能
    Link_Stack *p;
    p = Creat_stack();
    int n = 5;
    int input[6] = {10,20,30,40,50,60};
    /以依次入栈的方式创建整个栈//
    for(int i=0;i<n;i++){
        Push_stack(p, input[i]);
    }
    show_stack(p);
    出栈///
    Pop_stack(p);
    show_stack(p);
    return 0;
}

在这里插入图片描述

2.2 单结构体实现

  • 使用单结构体实现链表：
    • 在实现数据"入栈"操作时，需要将数据从链表的头部插入（单链表的头插法）；
    • 在实现数据"出栈"操作时，需要删除链表头部的首元节点；

2.2.0 栈的节点设计

  • C实现：
//链表中的节点结构
typedef struct lineStack{
    int data;
    struct lineStack * next;
}lineStack;

2.2.1 入栈

  • 将元素 1、2、3、4 依次入栈，等价于将各元素采用头插法依次添加到链表中，每个数据元素的添加过程如图所示：
    在这里插入图片描述
  • C实现：
//链表中的节点结构
typedef struct lineStack{
    int data;
    struct lineStack * next;
}lineStack;
//stack为当前的链栈，a表示入栈元素
lineStack* push(lineStack * stack,int a){
    //创建存储新元素的节点
    lineStack * line=(lineStack*)malloc(sizeof(lineStack));
    line->data=a;
    //新节点与头节点建立逻辑关系
    line->next=stack;
    //更新头指针的指向
    stack=line;
    return stack;
}

2.2.2 出栈

  • 若要将元素 3 出栈，根据"先进后出"的原则，要先将元素 4 出栈，也就是从链表中摘除，然后元素 3 才能出栈：
  • C 实现：
//栈顶元素出链栈的实现函数
lineStack * pop(lineStack * stack){
    if (stack) {
        //声明一个新指针指向栈顶节点
        lineStack * p=stack;
        //更新头指针
        stack=stack->next;
        printf("出栈元素：%d ",p->data);
        if (stack) {
            printf("新栈顶元素：%d\n",stack->data);
        }else{
            printf("栈已空\n");
        }
        free(p);
    }else{
        printf("栈内没有元素");
        return stack;
    }
    return stack;
}

2.2.3 实例

#include <stdio.h>
#include <stdlib.h>
typedef struct lineStack{
    int data;
    struct lineStack * next;
}lineStack;
lineStack* push(lineStack * stack,int a){
    lineStack * line=(lineStack*)malloc(sizeof(lineStack));
    line->data=a;
    line->next=stack;
    stack=line;
    return stack;
}
lineStack * pop(lineStack * stack){
    if (stack) {
        lineStack * p=stack;
        stack=stack->next;
        printf("弹栈元素：%d ",p->data);
        if (stack) {
            printf("栈顶元素：%d\n",stack->data);
        }else{
            printf("栈已空\n");
        }
        free(p);
    }else{
        printf("栈内没有元素");
        return stack;
    }
    return stack;
}
int main() {
    lineStack * stack=NULL;
    stack=push(stack, 1);
    stack=push(stack, 2);
    stack=push(stack, 3);
    stack=push(stack, 4);
    stack=pop(stack);
    stack=pop(stack);
    stack=pop(stack);
    stack=pop(stack);
    stack=pop(stack);
    return 0;
}

在这里插入图片描述

【 3. 顺序栈 】

  • 我们通过顺序表（底层实现是数组）模拟顺序栈/数组栈。思路为：在顺序表中设定一个实时指向栈顶元素的变量（一般命名为 top），top 初始值为 -1，表示栈中没有存储任何数据元素，及栈是"空栈"。一旦有数据元素进栈，则 top 就做 +1 操作；反之，如果数据元素出栈，top 就做 -1 操作。

在这里插入图片描述

3.1 入栈

  • 比如，模拟栈存储 {1,2,3,4} 的过程。最初，栈是"空栈"，即数组是空的，top 值为初始值 -1：
    在这里插入图片描述
  • 首先向栈中添加元素 1，我们默认数组下标为 0 一端表示栈底，因此，元素 1 被存储在数组 a[0] 处，同时 top 值 +1：
    在这里插入图片描述
  • 采用以上的方式，依次存储元素 2、3 和 4，最终，top 值变为 3：
    在这里插入图片描述
  • C 实现：
//元素elem进栈，a为数组，top值为当前栈的栈顶位置
int push(int* a,int top,int elem){
    a[++top]=elem;
    return top;
}

3.2 出栈

  • 将上图中的元素 2 出栈，则需要先将元素 4 和元素 3 依次出栈。当有数据出栈时，要将 top 做 -1 操作。因此，元素 4 和元素 3 出栈的过程分别如图所示：
    在这里插入图片描述
  • 上图中数组中元素的消失仅是为了方便初学者学习，其实，这里只需要对 top 值做 -1 操作即可，因为 top 值本身就表示栈的栈顶位置，因此 top-1 就等同于栈顶元素出栈。并且后期向栈中添加元素时，新元素会存储在类似元素 4 这样的旧元素位置上，将旧元素 覆盖。
  • C 实现：
//数据元素出栈
int pop(int * a,int top){
    if (top==-1) { //防止用户做 "栈中已无数据却还要数据出栈" 的错误操作
        printf("空栈");
        return -1;
    }
    printf("弹栈元素：%d\n",a[top]);
    top--;
    return top;
}

3.3 实例

  • 实例1：直接数组法
#include <stdio.h>
//元素elem进栈
int push(int* a, int top, int elem) {
    a[++top] = elem;
    return top;
}
//数据元素出栈
int pop(int* a, int top) {
    if (top == -1) {
        printf("空栈");
        return -1;
    }
    printf("弹栈元素：%d\n", a[top]);
    top--;
    return top;
}
int main() {
    int a[100];
    int top = -1;
    top = push(a, top, 3);
    top = push(a, top, 1);
    top = push(a, top, 4);
    top = push(a, top, 5);
    top = pop(a, top);
    top = pop(a, top);
    top = pop(a, top);
    top = pop(a, top);
    top = pop(a, top);
    return 0;
}

在这里插入图片描述

  • 实例2：构建结构体
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define maxn 10000
  
//结点设计
typedef struct stack{
    int data[maxn];
    int top;
}stack;
  
//创建
stack *init(){
    stack *s=(stack *)malloc(sizeof(stack));
    if(s==NULL){
        printf("分配内存空间失败");
        exit(0);
    }
    memset(s->data,0,sizeof(s->data));
    //memset操作来自于库文件string.h，其表示将整个空间进行初始化
    //不理解可以查阅百度百科https://baike.baidu.com/item/memset/4747579?fr=aladdin
    s->top=0;     //栈的top和bottom均为0（表示为空）
    return s;
}
  
//入栈push
void push(stack *s,int data){
    s->data[s->top]=data;
    s->top++;
}
  
//出栈pop
void pop(stack *s){
    if(s->top!=0){
        s->data[s->top]=0;  //让其回归0模拟表示未初始化即可
        s->top--;
    }
}
  
//模拟打印栈中元素
void print_stack(stack *s){
    for(int n=s->top-1;n>=0;n--){
        printf("%d\t",s->data[n]);
    }
    printf("\n");   //习惯性换行
}
  
int main(){
    stack *s=init();
    int input[5]={11,22,33,44,55};  //模拟五个输入数据
    for(int i=0;i<5;i++){
        push(s,input[i]);
    }
    print_stack(s);
    /
    pop(s);
    print_stack(s);
    return 0;
}

在这里插入图片描述

MR_Promethus
关注
  • 13
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
简单计算器C语言数据结构栈实现
10-31
C语言数据结构栈的较高级应用
c语言数据结构-栈
来自计科大一萌新的编程记录本
01-11 738
c语言数据结构-栈
数据结构——栈的详解
热门推荐
晴空๓
04-20 7万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
C语言 数据结构 栈的顺序表示和实现
C语言/数据结构/数学建模/深度学习/生物信息
01-12 2806
栈的顺序表示和实现 文章目录1 顺序栈结构2 基本操作函数3 整体代码test3.cStack.h4 运行结果5 附加题 栈的存储结构可以是顺序表或链表，该篇为顺序表存储 栈是后进先出的数据结构 1 顺序栈结构 栈结构体 top永远指向下一个 typedef struct Stack { DataType data[maxn]; // 作为栈元素的存储方式，数据类型为DataType int top; // top即栈顶指
数据结构——栈(C语言版)
qq_59774127的博客
10-30 6312
本文章以理论、图解、代码实战给大家讲清楚数据结构的每个知识点
栈-数据结构(C语言)
weixin_44681349的博客
05-13 1042
栈 我们在用浏览器打开网页的时候，时常会点击页面上的某个链接跳转到其它页面浏览，又会在新的页面上，点击链接跳转到另一个新页面。另外，如果想回到上一个页面，就会点击浏览器的“返回”按钮，再点击一下又会返回上一个页面，而且每次点击“返回”只能返回上一级，浏览器的这个功能是怎么实现的呢？ 浏览器的这个功能可以用 栈 来实现，当前浏览的页面我们叫它为栈顶元素，跳转到一个新页面我们叫元素入栈，点击“返回”按钮我们叫元素出栈，当然出栈前提是栈里要有元素，比如在浏览器里，如果已经返回到了最开始的页面，那就无法返回了。 栈
C语言数据结构 栈的基础操作
08-30
主要介绍了C语言数据结构 栈的基础操作的相关资料,需要的朋友可以参考下
C语言数据结构栈应用-进制转换
11-19
该源码 详细说明了c语言中 顺序栈在进制转换上的应用
C语言数据结构之栈简单操作
01-01
C语言数据结构之栈简单操作 实验： 编写一个程序实现顺序栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能： （1）初始化顺序栈 （2）插入元素 （3）删除栈顶元素 （4）取栈顶元素 （5）遍历顺序栈 ...
linux驱动-CCF-1 provider 注册时钟
2401_83458819的博客
04-24 426
struct clk_hw_onecell_data onecell 填充到struct of_clk_provider *cp 中的data。struct clk_hw 组成 struct clk_hw_onecell_data onecell。b. 调用 of_clk_add_hw_provider 根据 进一步生成of_clk_provider ，并添加到全局列表。void *data;//对应 clk_hw_onecell_data（包含clk provider 注册的所有数组）
【数据结构】三、栈和队列：2.顺序栈&共享栈（顺序栈的初始化，判空，进栈，出栈，读取栈顶，顺序栈实例）
来csdn只办三件事：开源！开源！还是***开源！
04-23 1173
因为顺序栈的缺点是栈的大小不可变，所以引出共享栈，两个栈共享一片空间。这片存储空间不单独属于任何一个栈，某个栈需要的多一点，它就可能得到更多的存储空间。两个栈的栈底在这片存储空间的两端，当元素入栈时，两个栈的栈顶指针相向而行。当他们下一个指针的位置在一起时，说明这个栈已经放满元素。C++是一门面向对象的高级语言，在我们编写代码中，常常离不开对对象的创建和清理对象资源。指向栈顶元素，一般存储的是数组的下标。top当前指向的位置是栈顶上面的一个没有元素的空位置。如果有abcde，5个元素，那么满栈top=4。
【Redis 开发】(Feed流的模式，GEO数据结构，BitMap,HyperLogLog)
最新发布
weixin_62513677的博客
04-27 565
如果我们需要统计UV值，我们可以使用HyperLogLog，它是从LogLog算法中派生出来的概率算法，用于确定非常大的集合的基数，但是它的单个存储的统计内存永远小于16kb，但是代价就是统计是概率性的有小于0.81%的误差，不过可以忽略。也叫做写扩散，发布的消息不需要写入到发件箱中，直接推送到被关注人的收件箱中并通过时间戳进行排序，延时低，但是比如说微博中的一些大V，粉丝人特别多，这样就会写很多。范围可以是圆形或矩形。:指定圆心、半径，找到该圆内包含的所有member，并按照与圆心之间的距离排序后返回。
数据结构中的串（String）：概念、操作和实际应用
JAZJD的博客
04-24 959
在计算机科学中，串 是由零个或多个字符组成的有限序列，是数据结构中常见的一种基本类型。它可以为空串，也可以是由字符组成的非空串。串通常用于表示文本数据，如文件内容、用户输入等，因此在算法和程序设计中占据着重要的地位。一个串可以是由字母、数字、符号等任意字符组成，字符的种类和个数没有固定限制。例如，"Hello, World!@#$%" 都是串的例子。串的重要性在于它是对文本数据进行处理和操作的基础，涉及字符串匹配、文本编辑、编译器设计等多个领域。因此，深入理解串的特性和操作对于程序设计人员至关重要。
数据结构-树和森林之间的转化
2302_80729149的博客
04-23 366
这里我们根据左儿子右爸爸的逻辑将每个子树转化为二叉树的形式，对于第一个树，b，c，d都是a的儿子，所以都放到a的左边，而bcd之间也是兄弟关系，一起放到右边，然后再将三个树转化完毕后依次相连，构成二叉树的形式。从树的二叉链表的定义可知，任何一棵和树对应的二叉树，其根节点的右子树必为空。这里我们举三个树，将这个由三个树组成的森林组成二叉树是这个样子的。下面我们说明一下详细过程，首先将每个树转化为二叉的状态，如图所示。
【大数据】LSM树，专为海量数据读写而生的数据结构
Joker_ZJN的博客
04-24 1004
一文详聊LSM树这种专为海量数据读写而生的数据结构
C#基础之冒泡排序
AMrss的博客
04-27 211
排序初探。
使用指针实现常见排序算法选择排序，直接插入排序和冒泡排序
2302_80782671的博客
04-27 229
void insertSort(int * p,int n) /*直接插入排序*/void selectSort(int *p,int n) /*选择排序*/void bubbleSort(int *p,int n) /*冒泡排序/{ if(*(p+j)> *(p+j+1))/*交换逆序元素*//*将范围内最小元素交换到位置i*/
数据结构之常见排序算法
m0_69468924的博客
04-24 1091
数据结构之常见排序算法
C语言：插入排序
2302_79730293的博客
04-23 474
C语言：插入排序
 数据结构栈和队列c语言
10-19
栈和队列是两种常见的数据结构，它们都可以用来存储一系列的数据，并且具有不同的特点和应用场景。 栈是一种后进先出（Last In First Out，LIFO）的数据结构，类似于一个＊＊＊、表达式求值、括号匹配等。 队列是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MR_Promethus

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值