数据结构---栈

最新推荐文章于 2024-08-08 16:32:53 发布
最新推荐文章于 2024-08-08 16:32:53 发布
阅读量324 收藏 1
点赞数 11
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66605944/article/details/137611220
版权

1. 概要

栈类型

1.满减栈

2,满增栈

3,空减栈

4.空增栈 1

满栈：top指示的是，最后一次入栈的元素

空栈：top指示的是，新元素待插的位置

增栈：随着元素的push,top地址变大

减栈，随着元素的push,top地址变小

栈是限定仅在表尾进行插入和删除操作的线性表。

先进后出、后进先出

栈顶:允许操作的一端

栈底:不允许操作的一端

入栈，出栈。

顺序栈 链式栈

30+2\5

1.创建 CreateSeqStack

2.销毁 DestroySeqStack

3.判断是否为空栈 IsEmptySeqStack

4.判断是否为满栈 IsFullSeqStack

5.压栈 PushSeqStack

6.出栈 PopSeqStack

2. 顺序栈 

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;
}

main.c

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


int main(int argc, char *argv[])
{
    SeqStack* ss = CreateSeqStack(10);
    

     DATATYPE data[]={
        {"zhansan",'m',20,90},
        {"lisi",'f',22,87},
        {"wangmazi",'m',21,93},
        {"guanerge",'m',40,60},
        {"liuei",'m',42,83},
    };

     int  i = 0 ;
     for(i = 0 ;i<5;i++)
     {
        PushSeqStack(ss,&data[i]);
     }
    int len  =GetSizeSeqStack(ss);

    for(i=0;i<len;i++)
    {
    
        DATATYPE* tmp = GetTopSeqStack(ss);
        printf("%s %d\n",tmp->name,tmp->score);
        PopSeqStack(ss);
    }

    return 0;
}

3. 链式栈

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 ;
}

main.c

#include "linkstack.h"
#include <stdio.h>

int main(int argc, char *argv[])
{
     DATATYPE data[]={
        {"zhansan",'m',20,90},
        {"lisi",'f',22,87},
        {"wangmazi",'m',21,93},
        {"guanerge",'m',40,60},
        {"liuei",'m',42,83},
    };

    LinkStackList* ls = CreateLinkStack();

    int i = 0 ;
    for(i = 0 ;i<5;i++)
    {
        PushLinkStack(ls,&data[i]);
    }

    int len = GetSizeLinkStack(ls);
    for(i = 0 ;i<len;i++)
    {
    
        DATATYPE* tmp = GetTopLinkStack(ls);
        printf("%s %d\n",tmp->name ,tmp->score );

        PopLinkStack(ls);
    }

    DestroyLinkStackList(&ls);
    return 0;
}

4.  练习

（）【】{} 的配对 -------使用的是顺序栈

#ifndef _SEQSTACK_H_ 
#define _SEQSTACK_H_  

typedef struct{

    char sym;
    int row;
    int col;
}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;
}

main.c

#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;
}

青栀..
关注
  • 11
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
栈概念及基本操作
fn1783553244的博客
07-10 386
数据结构-栈 概念 ：只允许一端进行操作的线性存储结构。存取模式为FIFO(先进先出)。 分类 顺序栈 ：满增栈，满减栈，空增栈，空减栈。 链表栈 。 详解 顺序栈详解 栈类型 解释 出入栈操作 满增栈 栈顶不为空，存储地址由低到高 入栈：top++，入栈数据出栈：出栈数据, top - - 满减栈 栈顶不为空，存储地址由高到低 入栈：top - -，入栈数据出栈：出栈数据，top++ 空增栈 栈顶为空，存储地址由低到高 入栈：入栈数据，top++ 出栈：top - -，出栈数据
数据结构---栈的实现
shijinghe的博客
03-27 3208
一、栈 学习栈之前我们需要认识栈究竟是什么东西。 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶 图解↓： 图中数据都是从栈顶进入，当图中1，2，3，4都进入，先出栈的只能是4，但也可以边进边出，举例：所以不一定出栈顺序就是4 3 2 1..
栈的四种情况
fade12345678的博客
03-19 3587
栈的四种情况 **满栈：**sp指针指向有内容的地址。因此，进栈是先移动指针再存；出栈是先出数据再移动指针 **空栈：**sp指针指向没有内容的地址。因此，进栈是先存再移动指针；出栈是先移动指针再出数据 **减栈：**sp指针向地址减小的方向移动。因此，进栈指针向下移动；出栈是指针向上移动 **增栈：**sp指针向地址增加的方向移动。因此，进栈指针向上移动；出栈是指针向下移动 **总结：**根据上面的栈的概念，可以组成四种栈的情况 满减栈：sp指针一开始指向有内容的地址，进栈先向下移动指针后再将内容存进
栈的四种方式、大端、小端模式的区别
Lin的博客
04-05 1183
栈的四种方式 根据栈指针指向，可分为满(Full)/空(Empty)： 满SP指向最后一个入栈的数据，需要先修改SP再入栈 空SP指向下一个空位置，先入栈再修改SP 根据压栈时SP的增长方向，可分为增/减： 增(Ascending)：SP变大 减(Descending)：SP变小 组合后，就有4种方式： 满增、满减， 空增，空减 note:我们最常用的是满减栈 满减栈： 大端、小端模式 大端模式，是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字
堆栈（stack）的四种类型
热门推荐
DangerousStool的博客
12-01 1万+
堆栈严格来说应该叫做栈（stack），先入后出 四种类型：满增栈、满减栈、空增栈、空减栈。 满、空栈区别：根据当前指针所在位置是否有东西。 满栈（full stack）：栈指针指向最后压入栈的数据，数据入栈时，sp先减一（或加一）再入栈。 空栈（empty stack）：栈指针指向下一个将要放入数据的位置，数据入栈时，先入栈sp再减一（或加一）。 增、减栈区别：根据堆栈的
数据结构-栈
不积硅步，无以至千里
04-14 3186
栈   栈是一种简单的数据结构。是一种先进后出的结构，类似于羽毛球桶里存放羽毛球，先放进去的羽毛球只能最后才能取出来。栈是一种线性数据结构，我们可以使用数组、链表等实现栈。利用栈的先进后出的特性可以实现很多功能。例如：文本中的括号匹配校验；浏览器访问记录的回退等功能。 括号的匹配校验 import java.util.Stack; /** * @author zhw */ public class Test { public static void main(String[] args) {
java数据结构-栈
小赵的呢
02-18 6314
栈 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的常见基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：判断一个栈是否为空，若栈为空则返回t
数据结构-栈及栈的应用
初始化的博客
07-19 4560
栈的概述 栈式一种重要的线性结构，属于一种操作受限的线性表 栈(stack) 是限定尽在表尾进行插入或删除操作的线性表 表尾端称为栈顶(top)，表头端称为栈底(bottom) 栈的元素先进后出(后进先出)，即最先进入栈的元素最后出栈 ...
数据结构---栈和队列
yphphy的博客
03-27 1216
栈 定义：限定仅在表尾进行插入和删除操作的线性表 ---------允许插入和删除的一端为栈顶，另一端为栈底；不含任何数据元素的栈为空栈 栈的示意图： 操作特性：后进先出（LIFO原则） 栈的表示：顺序栈或链栈 顺序栈： 栈空：栈顶指针=栈底指针 栈满：存储空间达最大值 队列 定义：只允许在一端进行插入操作，在另一端进行删除操作的线性表 --------允许插入的一端为队尾，允许删除的一端为队头；空队列：不含任何数据元素的队列 队列示意图： 操作特性：先进.
C语言数据结构 - 栈
Flin
11-24 2090
栈的定义 类似很多软件都有撤销的操作，这其实就是用栈这种方法来实现的，当然不同的软件具体实现代码会有差异，不过原理大多都是一样的。 栈(stack)是限定仅在表尾进行插入和删除操作的线性表。 我们把允许插入和删除的一端称为栈顶(top)，另一端称为栈低(bottom)，不含任何数据元素的栈称为空栈。栈又称为后进后出(Last In First Out)的线性表，简称LIFO结构。 栈的顺序存储结构及实现 它是顺序表的一种，具有顺...
数据结构-栈.zip_数据结构-栈
09-24
标题“数据结构-栈.zip_数据结构-栈”暗示了这个压缩包文件主要包含了关于数据结构中栈的讲解和示例。通过解压并分析其中的文件，我们可以进一步了解栈的基本概念和操作。 “栈测试.cpp”很可能是一个用C++编写的源...
C++实现数据结构-栈
11-10
C++实现数据结构-栈
数据结构-栈10
01-20
数据结构中的栈是一种重要的线性存储结构，其主要特点是遵循“先进后出”（FILO，First In Last Out）原则，即最后存入的元素最先被取出。栈的这一特性使得它在许多计算机算法和系统设计中发挥着关键作用。 1. 栈的...
数据结构-栈的C语言实现
01-20
数据结构-栈的C语言实现，随手笔记
【归并排序/快排/堆排序】912. 排序数组
m0_63530048的博客
08-07 333
维护大顶堆：从下往上，第一个有孩子节点的节点开始，取根节点、左孩子、右孩子之间的最大值 换到根节点处
排序算法3：归并排序与计数排序
2302_79964175的博客
08-08 531
Hello，小伙伴们，今天我们继续排序算法的学习，大家三连上车不迷路，我们现在开始今天的学习！！！
数据结构--第六天
最新发布
xujiashuo1的博客
08-08 1244
树是由。
【深度学习】P1 深度学习数据结构
weixin_43098506的博客
08-07 757
深度学习的数据结构——张量的概念与其基本操作
数据结构-插入运算详解
"该资源是南京理工考研的数据结构课件，主要内容涵盖了数据结构的基本概念、算法分析以及插入运算的详细解释。" 在计算机科学中，数据结构是编程的基础，它研究的是数据的组织方式和它们之间的关系。在《数据结构》...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值