数据结构 栈

已于 2024-03-22 17:54:23 修改
阅读量187 收藏
点赞数 1
文章标签： 数据结构
于 2024-03-22 17:42:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65339175/article/details/136947682
版权
本文详细介绍了栈的数据结构特性，包括栈的先进后出原则，以及顺序栈和链式栈的创建、操作方法。通过示例展示了如何使用C语言实现顺序栈和链式栈的功能，如插入、删除和获取栈顶元素等。
摘要由CSDN通过智能技术生成

栈：

     特点：

            栈是限定仅在表尾进行操作的结构

            先进后出，后进先出

栈顶：

         栈顶允许被操作

栈底：

          栈底不允许被操作

按照物理机构设计栈分为：顺序栈  链式栈

顺序栈：

seqstack.h


#ifndef _SEQSTACK_H_ 
#define _SEQSTACK_H_  



typedef struct	person {
	char name[32];
	char sex;
	int age;
	int score;
}DATATYPE;
typedef struct list {
	DATATYPE *head;
	int tlen;
	int top;
}SeqStack;


SeqStack* CreateSeqStack(int len);
int DestroySeqStack(SeqStack* ss);
int PushSeqStack(SeqStack* ss, DATATYPE* data);
int PopSeqStack(SeqStack*ss);
DATATYPE* GetTopSeqStack(SeqStack* ss);
int IsEmptySeqStack(SeqStack* ss);
int IsFullSeqStack(SeqStack* ss);
int GetSizeSeqStack(SeqStack*ss);

#endif

     seqstack.c

#include "seqstack.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

SeqStack* CreateSeqStack(int len)
{
    SeqStack* ss = (SeqStack*)malloc(sizeof(SeqStack));
    if(NULL == ss)
    {
        perror("CreateSeqStack malloc 1");
        return NULL;
    }

    ss->head =(DATATYPE*) malloc(sizeof(DATATYPE)*len);
    if(NULL == ss->head )
    {
        
        perror("CreateSeqStack malloc 1");
        return NULL;
    }
    ss->tlen  = len;
    ss->top =  0;
    return ss;
}
int PushSeqStack(SeqStack* ss, DATATYPE* data)
{

    if(IsFullSeqStack(ss))
    {
        return 1;
    }
    memcpy(&ss->head[ss->top++],data,sizeof(DATATYPE));
    return 0;
}
int PopSeqStack(SeqStack*ss)
{
    if(IsEmptySeqStack(ss))
    {
        return 1;
    }
    ss->top--;
    return 0;
}

int IsFullSeqStack(SeqStack* ss)
{
    return ss->top  == ss->tlen ;
}
int IsEmptySeqStack(SeqStack* ss)
{
    return 0 == ss->top ;
}
DATATYPE* GetTopSeqStack(SeqStack* ss)
{
    if(IsEmptySeqStack(ss))
    {
        return NULL;
    }
    return &ss->head[ss->top -1];
}
int GetSizeSeqStack(SeqStack*ss)
{
    return ss->top;
}

 示例：

实现（{【括号匹配

#include "seqstack.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int do_check(char *buf,SeqStack* ss,int row)
{   
    DATATYPE data;
    int col =1;
    DATATYPE* tmp=NULL;
    while(*buf)
    {
        //memset(&data,0,sizeof(data));
        bzero(&data,sizeof(data));
        switch(*buf)
        {
        case '(':
            data.sym = *buf;
            data.row = row;
            data.col = col;
            PushSeqStack(ss,&data);
            break;
        case '[':
            data.sym = *buf;
            data.row = row;
            data.col = col;
            PushSeqStack(ss,&data);
            break;
        case '{':
            data.sym = *buf;
            data.row = row;
            data.col = col;
            PushSeqStack(ss,&data);
            break;

        case ')':
            tmp= GetTopSeqStack(ss);
            if(NULL == tmp)
            {
               printf("buf sym:%c row:%d col:%d\n",*buf,row,col); 
               return 1;
            }
            if('('==tmp->sym )
            {
                PopSeqStack(ss);
            }
            else 
            {

                printf("1.top error sym:%c row:%d col:%d or 2 buf sym:%c row:%d col%d\n",
                       tmp->sym ,tmp->row ,tmp->col,*buf,row,col ); 
                return 1;
            }
            break;
        case ']':
            tmp= GetTopSeqStack(ss);
            if(NULL == tmp)
            {
               printf("buf sym:%c row:%d col:%d\n",*buf,row,col); 
               return 1;
            }
            if('['==tmp->sym )
            {
                PopSeqStack(ss);
            }
            else 
            {

                printf("1.top error sym:%c row:%d col:%d or 2 buf sym:%c row:%d col%d\n",
                       tmp->sym ,tmp->row ,tmp->col,*buf,row,col ); 
                return 1;
            }
            break;
        case '}':
            tmp= GetTopSeqStack(ss);
            if(NULL == tmp)
            {
               printf("buf sym:%c row:%d col:%d\n",*buf,row,col); 
               return 1;
            }
            if('{'==tmp->sym )
            {
                PopSeqStack(ss);
            }
            else 
            {

                printf("1.top error sym:%c row:%d col:%d or 2 buf sym:%c row:%d col%d\n",
                       tmp->sym ,tmp->row ,tmp->col,*buf,row,col ); 
                return 1;
            }
            break;
        }
        buf++;
        col++;
    }

    return 0;
}
int main(int argc, char *argv[])
{
    SeqStack* ss = CreateSeqStack(50);  

    FILE* fp = fopen("/home/linux/1.c","r");
    if(NULL == fp)
    {
        perror("fopen");
        exit(1);
    }
    int flag =  0;
    int row =1;
    while(1)
    {
        char buf[512]={0};
        if(fgets(buf,sizeof(buf),fp))
        {
            int ret = do_check(buf,ss,row);
            if(ret!= 0 )
            {
                flag = 1;
                break;
            }
        }
        else 
        {
            break;
        }

        row++;
    }

    if(1 == flag)
    {
        return 0;
    }
    else 
    {
        if(IsEmptySeqStack(ss))
        {
            printf("ok!");
        }
        else 
        {

            DATATYPE* tmp = GetTopSeqStack(ss);
            printf("%c row:%d col:%d\n",tmp->sym 
                   ,tmp->row ,tmp->col);
        }

    }



    return 0;
}

链式栈：

linkstack.h

#ifndef _LINKSTACK_H_ 
#define _LINKSTACK_H_

typedef struct {
	char name[32];
	char sex;
	int age;
	int score;
}DATATYPE;

typedef struct stack_node {
	DATATYPE data;
	struct stack_node *next;
}LinkStackNode;

typedef struct  {

    LinkStackNode* top;
	int clen;
}LinkStackList;


LinkStackList* CreateLinkStack();
int DestroyLinkStackList(LinkStackList**ls);
int PushLinkStack(LinkStackList* ls, DATATYPE*data);
int PopLinkStack(LinkStackList*ls);
DATATYPE* GetTopLinkStack(LinkStackList*ls);
int IsEmtpyLinkStack(LinkStackList* ls);
int GetSizeLinkStack(LinkStackList*ls);

#endif

linkstack.c

#include "linkstack.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
LinkStackList* CreateLinkStack()
{
    LinkStackList* ls = (LinkStackList*)malloc(sizeof(LinkStackList));
    if(NULL == ls)
    {
        perror("CreateLinkStack malloc");
        return NULL;
    }
    ls->top = NULL;
    ls->clen = 0 ;
    return ls;
}
int DestroyLinkStackList(LinkStackList**ls)
{
    int len = GetSizeLinkStack(*ls);
    int i = 0 ;
    for(i = 0 ;i<len;i++)
    {
        PopLinkStack(*ls);
    }

    free(*ls);
    *ls =NULL;
    return 0;
}
int PushLinkStack(LinkStackList* ls, DATATYPE*data)
{
    LinkStackNode* newnode = (LinkStackNode*)malloc(sizeof(LinkStackNode));
    if(NULL == newnode)
    {
        perror("PushLinkStack malloc");
        return 1;
    }
    memcpy(&newnode->data ,data,sizeof(DATATYPE));
    newnode->next = NULL;
    if(IsEmtpyLinkStack(ls))
    {
    
        ls->top = newnode;
    }
    else 
    {
        newnode->next = ls->top ;
        ls->top = newnode;
    }
    ls->clen ++;
    return 0;


}
int PopLinkStack(LinkStackList*ls)
{
    if(IsEmtpyLinkStack(ls))
    {
        return 1;
    }
    LinkStackNode* tmp = ls->top ;
    ls->top = ls->top ->next ;
    free(tmp);
    ls->clen --;
    return 0;
}
DATATYPE* GetTopLinkStack(LinkStackList*ls)
{
    if(IsEmtpyLinkStack(ls))
    {
        return NULL;
    }
    return &ls->top->data ;
}
int IsEmtpyLinkStack(LinkStackList* ls)
{
    return  0 == ls->clen ;
}
int GetSizeLinkStack(LinkStackList*ls)
{
    return ls->clen ;
}

示例:

实现30*2+5四则运算 简单计算器

#include "linkstack.h"
#include <stdio.h>
#include <string.h>
//30*2+5
//
int num =0;

void get_num(char c)
{
    num = num*10 +c-'0' ;
}
int get_pority(char c)
{
    switch(c)
    {
    case '+':
        return 1;
    case '-':
        return 2;
    case '*':
        return 3;
    case '/':
        return 4;

    }
    return -1;
}
int get_result(int num1,int num2,char op)
{
    switch(op)
    {
    case '+':
        return num1+num2;
    case '-':
        return num1-num2;
    case '*':
        return num1*num2;
    case '/':
        return num1/num2;

    }
    return 0;
}
int main(int argc, char *argv[])
{

    char buf[]="30*2+5";
    LinkStackList* ls_num = CreateLinkStack();
    LinkStackList* ls_sym = CreateLinkStack();
    char* tmp = buf;
    DATATYPE data;
    int flag = 0 ;
    while(*tmp)
    {
        bzero(&data,sizeof(data));
        if(*tmp>='0' && *tmp<='9')
        {

            get_num(*tmp);
            tmp++;
            continue;
        }
        if(0 == flag)
        {
            data.num = num;
            PushLinkStack(ls_num,&data);
            num=0;
        }

        DATATYPE* top =GetTopLinkStack(ls_sym);
        if(IsEmtpyLinkStack(ls_sym) || get_pority(top->sym) < get_pority(*tmp) )
        {
            bzero(&data,sizeof(data));
            data.sym = *tmp;
            PushLinkStack(ls_sym,&data);
            flag = 0 ;
        }
        else 
        {

            DATATYPE* top_num = GetTopLinkStack(ls_num);
            int num2 = top_num->num;
            PopLinkStack(ls_num);
            top_num = GetTopLinkStack(ls_num);
            int num1 =top_num->num;
            PopLinkStack(ls_num);

            DATATYPE* top_sym = GetTopLinkStack(ls_sym);
            char op=top_sym ->sym;
            int result = get_result(num1,num2,op);
            PopLinkStack(ls_sym);

            bzero(&data,sizeof(data));
            data.num = result;
            PushLinkStack(ls_num,&data);
            flag = 1;
            continue;
        }
        tmp++;
    }

    bzero(&data,sizeof(data));
    data.num = num;
    PushLinkStack(ls_num ,&data);

    while(!IsEmtpyLinkStack(ls_sym))
    {

        DATATYPE* top_num = GetTopLinkStack(ls_num);
        int num2 = top_num->num;
        PopLinkStack(ls_num);
        top_num = GetTopLinkStack(ls_num);
        int num1 =top_num->num;
        PopLinkStack(ls_num);

        DATATYPE* top_sym = GetTopLinkStack(ls_sym);
        char op=top_sym ->sym;
        int result = get_result(num1,num2,op);
        PopLinkStack(ls_sym);

        bzero(&data,sizeof(data));
        data.num = result;
        PushLinkStack(ls_num,&data);

    }

    DATATYPE* top_result = GetTopLinkStack(ls_num);
    printf("result is %d\n",top_result->num);
    return 0;
}

m0_65339175
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构之——栈
WenJieya的博客
03-27 7009
数据结构之——栈 一：栈的定义： 栈是限定是限定仅在表位进行插入和删除操作的线性表，栈又称为先进后出（Last In First Out）的线性表，简称LIFO结构。 栈顶：允许插入和删除的一端称为栈顶。 栈底：不可以进行插入和删除操作。 空栈：不含任何数据元素的栈称为空栈。 理解栈的定义需要注意几点： 1：它是一个线性表，即说明栈元素具有 线性关系，即 前驱后继 关系。只不 过它是一种特殊的线性表而已。 2：定义中说在线性表的表的表尾进行插入和删除操作，注意这里表尾指的是
c语言 数据结构栈的创建
lovemingshu的博客
06-18 4841
栈是一种线性数据结构，采用先进后出的方式管理数据其中一段固定，称之为栈底，另一端随着数据进出而随时改变位置，叫做栈顶，用程序实现栈一定要记录栈顶的位置，往栈放入数据操作称之为入栈(压栈)，从栈中取出数据的操作称之为出栈(弹栈)，可以使用顺序结构来实现栈，这种栈叫顺序栈，也可以使用链式结构来实现栈，这种栈叫链式栈。 下面就是顺序栈的创建步骤和代码实现过程，用的是多文件的形式，我是在Linux系统下编...
数据结构——栈的详解
晴空๓
04-20 8万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
C++数据结构——栈
热门推荐
GeekZW的博客
06-25 16万+
C++数据结构——栈 最近计划再复习一遍数据结构，看到一篇博客：https://www.cnblogs.com/QG-whz/p/5170418.html#_label0。 1、栈(Stack)是一种线性存储结构，它具有如下特点： ...
C语言数据结构——栈
wxk2227814847的博客
03-01 2056
在计算机科学中，数据结构是组织、管理和存储数据的有效方式，以便可以高效地访问和修改数据。栈是一种基本的数据结构，它遵循特定的操作顺序，即后进先出（LIFO）。由于其简单和高效的特性，在许多算法和系统功能中都有应用，如系统调用栈、表达式求值和回溯算法等。栈是一种简单而强大的数据结构，它在算法设计和系统实现中扮演着重要的角色。通过静态或动态的方式实现栈，可以在不同的应用场景中有效地利用其后进先出的特性。深入理解栈的工作原理和应用，对于学习更复杂的数据结构和算法是非常有帮助的。
数据结构 栈 入栈 输出 出栈
shangxianjiao的博客
05-16 4972
数据结构 栈 入栈 输出 出栈 #include<bits/stdc++.h> /* #include<iostream> #include<> */ using namespace std; //pA->p(Next)=pB->p(top)含义是pA指向pB typedef struct Node//有节点的数据类型 { int data;//数据域 struct Node * pNext; }NODE,*PNODE; typedef str
C语言 数据结构 栈的顺序表示和实现
C语言/数据结构/数学建模/深度学习/生物信息
01-12 3078
栈的顺序表示和实现 文章目录1 顺序栈结构2 基本操作函数3 整体代码test3.cStack.h4 运行结果5 附加题 栈的存储结构可以是顺序表或链表，该篇为顺序表存储 栈是后进先出的数据结构 1 顺序栈结构 栈结构体 top永远指向下一个 typedef struct Stack { DataType data[maxn]; // 作为栈元素的存储方式，数据类型为DataType int top; // top即栈顶指
数据结构——栈详解
m0_54615144的博客
07-27 2902
栈(Stack)是一种线性存储结构，它具有如下特点： （1）栈中的数据元素遵守“先进后出"(First In Last Out)的原则，简称FILO结构。（后进先出的叫法，也是可以的） （2）限定只能在栈顶进行插入和删除操作。 2、栈的相关概念： （1）栈顶与栈底：允许元素插入与删除的一端称为栈顶，另一端称为栈底。 （2）压栈：栈的插入操作，叫做进栈，也称压栈、入栈。 （3）弹栈：栈的删除操作，也叫做出栈。...
数据结构之栈结构
weixin_45641191的博客
03-08 1580
认识栈结构 栈是一种非常常见的数据结构，并且在程序中的应用非常广泛. 数组 我们知道数组是一种线性结构，并且可以在数组的任意位置插入和删除数据. 但是有时候，我们为了实现某些功能，必须对这种任意性加以限制. = 而栈和队列就是比较常见的受限的线性结构，我们先来学习栈结构. 栈结构示意图 栈( stack)，它是一种受限的线性表后进先出(LIFO) 其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。 LIFO(last in first out)表示就是后进入
数据结构之栈总结
Grand.的博客
05-16 1725
数据结构之栈
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数据结构栈的实验报告.doc
07-11
实验报告的主题是关于数据结构中的顺序栈的基本操作，主要涵盖了栈的初始化、进栈、出栈等核心概念。顺序栈是一种特殊的线性表，它的特点是只允许在一端进行插入和删除操作，这一端称为栈顶。 1. **栈的类型定义**...
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
数据结构 栈的操作实例详解
08-30
数据结构 栈的操作实例详解 数据结构中的栈是一种基本的数据结构，它的操作包括初始化、入栈、出栈、空栈判断等。下面我们将详细介绍栈的操作实例。 栈的定义 栈是指按照后进先出的原则来存储和取出元素的数据...
数据结构----栈
新手嵌入式学习的博客
08-19 953
数据结构顺序栈和链式栈。
集合及数据结构第三节————包装类和简单认识泛型
2301_79418684的博客
08-19 1149
包装类和简单认识泛型 1. 基本数据类型和对应的包装类 2. 装箱和拆箱 3. 泛型 4. 泛型类的使用 5. 裸类型(Raw Type) （了解） 6. 泛型如何编译的 7. 泛型的上界 8. 泛型方法
【数据结构-距离合】力扣1685. 有序数组中差绝对值之和
最新发布
sjsjs11的博客
08-20 320
换句话说， result[i] 等于 sum(|nums[i]-nums[j]|) ，其中 0 <= j < nums.length 且 j!请你建立并返回一个整数数组 result，它跟 nums 长度相同，且result[i] 等于 nums[i] 与数组中所有其他元素差的绝对值之和。，可以得到每个元素和其他元素的绝对值之和与该元素以及左边元素和及右边元素和之间的关系，进行计算即可。输入：nums = [1,4,6,8,10]输出：[24,15,13,15,21]输入：nums = [2,3,5]
数据结构（邓俊辉）学习笔记】优先级队列 06——完全二叉堆：批量建堆
weixin_44399845的博客
08-18 874
完全二叉堆：批量建堆
数据结构-队列
yandadzf的博客
08-20 457
队列是一种先进先出（FIFO, First In First Out）的数据结构。它的基本特性是：在队列中，元素的插入（入队）发生在队尾，元素的删除（出队）发生在队头。队列通常用于需要按顺序处理数据的场景。
数据结构栈详解：栈的定义、操作及应用
"特殊线性表——栈-数据结构栈，课件" 栈是一种特殊的数据结构，它具有“后进先出”（Last In First Out，简称LIFO）的特点。在这个课件中，主要讨论了栈的基本概念、存储结构以及一些实际应用。 1. 栈的定义 栈是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值