C语言数据结构[栈和队列][括号匹配、中缀表达式运算]

最新推荐文章于 2022-07-26 11:36:09 发布
最新推荐文章于 2022-07-26 11:36:09 发布
阅读量149 收藏 1
点赞数
分类专栏： # C语言数据结构 文章标签： 数据结构 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46765649/article/details/125109902
版权

一.栈

在这里插入图片描述
特点：栈为后进先出类型

1.链栈基础

解释：入栈采用头插法的方法;出栈通过读取链表第一个值就能删除，出栈时要返回删除的值

1.1 初始化

typedef struct student
{
    char data;
    struct student* next;
} NODE;
// 初始化
NODE* list_init()
{
    NODE* p= (NODE*)malloc(sizeof(NODE));
    p->data='/0';
    p->next=NULL;
    return p;
}

1.2 入栈

typedef struct student{
    int data;
    struct student* next;
}NODE;
// 初始化
NODE* list_init(){
    NODE* p= (NODE*)malloc(sizeof(NODE));
    p->data=0;
    p->next=NULL;
}

1.3 出栈

// 出栈->去掉第一个 0 1 并且返回值
char list_remove(NODE* p)
{
    NODE* death=p->next;
    p->next=death->next;
    char data=death->data;
    free(death);
    return data;
}

1.4 判断栈是否空

// 判断栈是否空
int list_subject(NODE* p){
    NODE* subject=p;
    if(subject->next==NULL){
        return 0;
    }else{
        return 1;
    }

}

1.5 打印

// 打印展示栈目前的情况
void list_printf(NODE* p){
    NODE* print=p->next;
    while(print){
        printf("%c\n",print->data);
        print=print->next;
    }
}

1.6 主程序

int main(){
    NODE* p=list_init();
    list_insert(p,120);
    list_insert(p,10);
    list_insert(p,30);
    list_remove(p);
    list_printf(p);
    return 0;
}

2.链栈实践

2.1 括号匹配

// 链栈
#include <stdio.h>
#include <stdlib.h>
typedef struct student
{
    char data;
    struct student* next;
} NODE;
// 初始化
NODE* list_init()
{
    NODE* p= (NODE*)malloc(sizeof(NODE));
    p->data='/0';
    p->next=NULL;
    return p;
}
// 入栈->头插法 0 1 2 3
void list_insert(NODE* p,char data)
{
    int i;
    NODE* node = (NODE*)malloc(sizeof(NODE));
    if(node)
    {
        node->data=data;
        node->next=p->next;
        p->next=node;
    }
    else
    {
        printf("分配已经失败，程序错误");
    }
}
// 出栈->去掉第一个 0 1 并且返回值
char list_remove(NODE* p)
{
    NODE* death=p->next;
    p->next=death->next;
    char data=death->data;
    free(death);
    return data;
}
// 打印展示栈目前的情况
void list_printf(NODE* p)
{
    NODE* print=p->next;
    while(print)
    {
        printf("%c\n",print->data);
        print=print->next;
    }
}
// 判断栈是否空
int list_subject(NODE* p)
{
    NODE* subject=p;
    if(subject->next==NULL)
    {
        return 0;
    }
    else
    {
        return 1;
    }

}
int main()
{
    int i=0,value_subject,value_subject_isnull;
    char temporary;
    NODE* p=list_init();
    char str[]="{[]()}";
    while(str[i])
    {
        if(str[i]=='{'||str[i]=='('||str[i]=='[')
        {
            list_insert(p,str[i]);
        }else{
            temporary= list_remove(p);
            if(str[i]==')'&&temporary=='('){
                value_subject=1;
            }else if(str[i]=='}'&&temporary=='{'){
                value_subject=1;
            }else if(str[i]==']'&&temporary=='['){
                value_subject=1;
            }else{
                value_subject=0;
                break;
            }
        }
        i++;
    }
    value_subject_isnull = list_subject(p);
    if(value_subject&&value_subject_isnull==0){
           printf("结果：语法正确");
    }else{
           printf("结果：语法错误");
    }
    return 0;
}

2.2 中缀表达式运算

思路：写出两个栈，分别为A和B，A栈只存数字，B栈存放有运算等级的符号。B栈顶部原则是最高级在顶部。当最高级在顶部，如果遇到低级的进入，最高级就需要出来，取出A中的数据进行运算。当遇到界限符，优先遵守下面规则，一直加入直到闭合，然后取出括号进行运算

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
// 数字
typedef struct studenta
{
    float data;
    struct studenta* next;
} Node_Number;
// 符号
typedef struct studentb
{
    char data;
    struct studentb* next;
} Node_Sign;
// 存放数字的栈
Node_Number* list_init_number();
void list_insert_number(Node_Number* p,float data);
float list_remove_number(Node_Number* p);
void list_printf_number(Node_Number* p);
// 存放符号的栈
Node_Sign* list_init_sign();
void list_insert_sign(Node_Sign* p,char data);
char list_remove_sign(Node_Sign* p);
void list_printf_sign(Node_Sign* p);
// 优先级
int grade(char data)
{
    if(data=='(')
    {
        return 4;
    }
    else if(data=='/')
    {
        return 3;
    }
    else if(data=='*')
    {
        return 2;
    }
    else if(data=='+'||data=='-')
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
// 判断是否要直接插入
int subject_grade(Node_Sign* p,char data)//1 2 ;+ - *
{
    if(p->next==NULL)
    {
        return 1;
    }
    else
    {
        if(p->next->data=='(')// 左括号优先级高的特殊情况，这样写是为了继续入栈
        {
            return 1;
        }
        else if(grade(data)>=grade(p->next->data))// 正常优先高遇到低要出
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
}
float calculation(char n,float a,float b)
{
    float temporary;
    switch(n)
    {
    case '*':
        temporary=b*a;
        break;
    case '/':
        temporary=b/a;
        break;
    case '+':
        temporary=b+a;
        break;
    case '-':
        temporary=b-a;
        break;
    }
    return temporary;
}
int main()
{
    int i=0;
    char target[]="511.5+2*(3+5+4)*(5+6)/5+(5*3)";
    Node_Number* number=list_init_number();// 数据
    Node_Sign* sign=list_init_sign();// 运算符号
    while(target[i])
    {
        if(target[i]>'0'&&target[i]<'9')// 数字直接插入
        {
            float t=0;// 字符串转换
            while(target[i]>'0'&&target[i]<'9'||target[i]=='.')
            {
                if(target[i]=='.')
                {
                    i++;
                    int j=1;
                    while(target[i]>'0'&&target[i]<'9')
                    {

                        t=t+(float)(target[i]-'0')/pow(10,j);
                        j++;
                        i++;
                    }
                }
                else
                {
                    t = t*10+target[i]-'0';
                    i++;
                }

            }
            list_insert_number(number,t);
        }
        else // 符号
        {
            if(target[i]==')')
            {
                Node_Sign* p=sign->next;
                while(p->data!='(')
                {
                    char n=p->data;
                    float a=list_remove_number(number);
                    float b=list_remove_number(number);
                    float result=calculation(n,a,b);
                    list_insert_number(number,result);
                    p=p->next;
                    list_remove_sign(sign);
                }
                list_remove_sign(sign);// 移除左括号
            }
            else if(subject_grade(sign,target[i]))// 正常
            {
                list_insert_sign(sign,target[i]);
            }
            else  // 先删除再插入
            {
                // 移除
                while(grade(target[i])<grade(sign->next->data))
                {
                    char n=list_remove_sign(sign);
                    float a=list_remove_number(number);
                    float b=list_remove_number(number);
                    float result= calculation(n,a,b);
                    // 加入
                    list_insert_number(number,result);
                }
                list_insert_sign(sign,target[i]);
            }
            i++;
        }

    }
    Node_Sign* flag=sign->next;

    while(flag)
    {
        char n=flag->data;
        float a=list_remove_number(number);
        float b=list_remove_number(number);
        float result= calculation(n,a,b);
        list_insert_number(number,result);
        flag=flag->next;
        list_remove_sign(sign);
    }

    printf("result=%.2f",number->next->data);
    return 0;
}
// 存放数字
Node_Number* list_init_number()
{
    Node_Number* p= (Node_Number*)malloc(sizeof(Node_Number));
    p->data=0;
    p->next=NULL;
    return p;
}
void list_insert_number(Node_Number* p,float data)
{
    int i;
    Node_Number* node = (Node_Number*)malloc(sizeof(Node_Number));
    if(node)
    {
        node->data=data;
        node->next=p->next;
        p->next=node;
    }
    else
    {
        printf("分配已经失败，程序错误");
    }
}
float list_remove_number(Node_Number* p)
{
    Node_Number* death=p->next;
    p->next=death->next;
    float data=death->data;
    free(death);
    return data;
}
void list_printf_number(Node_Number* p)
{
    Node_Number* print=p->next;
    while(print)
    {
        printf("%f  %p\n",print->data,print->next);
        print=print->next;
    }
}
// 存放符号
Node_Sign* list_init_sign()
{
    Node_Sign* p= (Node_Sign*)malloc(sizeof(Node_Sign));
    p->data=0;
    p->next=NULL;
    return p;
}
void list_insert_sign(Node_Sign* p,char data)
{
    int i;
    Node_Sign* node = (Node_Sign*)malloc(sizeof(Node_Sign));
    if(node)
    {
        node->data=data;
        node->next=p->next;
        p->next=node;
    }
    else
    {
        printf("分配已经失败，程序错误");
    }
}
char list_remove_sign(Node_Sign* p)
{
    Node_Sign* death=p->next;
    p->next=death->next;
    int data=death->data;
    free(death);
    return data;
}
void list_printf_sign(Node_Sign* p)
{
    Node_Sign* print=p->next;
    while(print)
    {
        printf("%c 自己%p 下一个%p\n",print->data,print,print->next);
        print=print->next;
    }
}

二.队列

在这里插入图片描述
特点：先进先出类型

1.链队列

1.1 初始化

typedef struct student
{
    int data;
    struct student* pre;
    struct student* next;
} NODE;
// 初始化
NODE* list_init()
{
    NODE* p= (NODE*)malloc(sizeof(NODE));
    p->data='/0';
    p->pre=p;
    p->next=p;
    return p;
}

1.2 入列

// 入队列->头插法 0 1 2 3
void list_insert(NODE* p,int data)
{
    int i;
    NODE* node = (NODE*)malloc(sizeof(NODE));
    if(node)// 0 2 4
    {
        node->data=data;
        node->pre=p;
        node->next=p->next;
        p->next=node;
        node->next->pre=node;
        if(node->next==p) // 应对数据插到队尾，头节点pre的处理
        {
            p->pre=node;
        }
    }
    else
    {
        printf("分配已经失败，程序错误");
    }
}

1.3 出列

// 出队列->去掉尾部 0
void list_remove(NODE* p)
{
    NODE * tail=p->pre;// 选到最后一个
    tail->pre->next=p;
    p->pre=tail->pre;// 最后一个的前一个把指针指向开头
    free(tail);

}

1.4 打印

// 打印展示栈目前的情况
void list_printf(NODE* p)
{
    NODE* print=p->next;
    while(print!=p)
    {
        printf("%d\n",print->data);
        print=print->next;

    }
}

1.5 主程序

int main()
{
    NODE* p=list_init();
    list_insert(p,155);
    list_insert(p,15);
    list_insert(p,1);
    list_remove(p);
    list_printf(p);
    return 0;
}
黑日里不灭的light
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
中缀表达式求值
12-20
在计算机科学领域，中缀表达式是我们...总之，中缀表达式求值是一个经典的问题，它涉及到了C语言编程、数据结构（如栈和队列）、以及算法设计。通过解决这个问题，你可以深入理解这些基础知识，并提高解决问题的能力。
C语言数据结构之简易计算器
08-28
1. C语言数据结构：C语言数据结构是指使用C语言编写的数据结构，包括数组、链表、栈、队列等。 2. 简易计算器：简易计算器是指一个基本的计算器程序，能够进行加减乘除等基础运算操作。 3. 后缀表达式：后缀表达式...
C语言 实现中缀表达式转后缀表达式并求值(附加括号匹配判断)
qq_39768922的博客
06-22 1802
1、栈的基本操作函数 Stack.c #include "Stack.h" //栈的相关操作 void InitStack(SqStack* S) { //初始化 S->top = -1; } Status IsEmpty(SqStack S) { //判空 if (S.top == -1) return TRUE; else return FALSE; } Status Push(SqStack* S, char c) { //入栈 if (S->top == M.
数据结构【完整代码】之（C语言实现【栈与队列】实现括号匹配([{ ）
Zhou_LC的博客
10-31 648
本文包含两个文件的代码和两张测试效果图： StackAndQueue.h文件： 用于存储信息：存放函数、结构体、栈的函数实现、变量名等 blockMatch.cpp文件： 用于测试 效果图：（位于最上方） 测试图： StackAndQueue.h文件: #include<stdio.h> #include <string.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 2
数据结构入门9 - 栈/队列『有效的括号| 用栈实现队列』
Bennett_G博客
11-13 227
????一分耕耘，一分收获????[= 反转链表 =]题目描述解题思路 ????????????此系列仅为记录本人补充学习数据结构相关知识，有兴趣的，大家可以共同学习???????????? [= 反转链表 =] 题目描述 题目传送门 解题思路 ...
c语言程序:编写一程序,检测任意表达式中的括号是否配对.,试用C语言设计一个程序,程序的功能是接收任意输入一个算术表达式,判断表达式中的括号是否配对出现....
weixin_32742203的博客
05-21 1240
//最近的栈作业~#includeusingnamespacestd;classStack{private:intmaxSize;inttop;int*p;public:Stack(intsize){maxSize=size;top=-1;p=newint[maxSize];}~Stack(){delete[]p;}voidClear()...
C语言实现括号匹配，中缀表达式转后缀表达式并计算具体代码实现
MistyWood的博客
08-13 1873
1.在本项目拟采用顺序栈来实现。 顺序栈的存储定义 typedef struct stack { SElemType *base;//栈底指针 SElemType *top;//栈顶指针 int stacksize;//栈分配的存储空间大小 }SqStack; 2.主要功能函数设计及算法描述 （1）初始化栈 算法描述：初始化空栈，包括顺序栈存储单元的分配等。 void Ini...
数据结构实验报告-栈与队列-中缀表达式求值-实验内容及要求.docx
05-03
《数据结构实验报告-栈与队列-中缀表达式求值》 实验的主要目标是掌握数据结构中的栈与队列的应用，特别是如何利用栈来解决中缀表达式的求值问题。在这个实验中，学生需要从键盘接收输入的中缀表达式，然后通过堆栈...
【精品课件】数据结构与算法 数据结构与C语言 data structure课程 第3章 栈和队列（共150页）.ppt
11-05
同时，通过案例分析，如一元多项式的运算、括号匹配和表达式求值，可以加深对栈和队列操作的理解，提升编程能力。 总结来说，本章"数据结构与算法"的内容涵盖了栈和队列的定义、特性、存储结构、运算规则以及在...
数据结构各章节算法实现（C语言版）.docx
10-12
2. **栈和队列**：栈是后进先出（LIFO）的数据结构，队列则是先进先出（FIFO）的数据结构。 - **行编辑器**：利用栈实现简单的文本编辑功能，如撤销操作。 - **后缀表达式求值**：将中缀表达式转换为后缀表达式...
【数据结构】实验四 栈与队列的应用（括号匹配与舞伴问题）
weixin_61693556的博客
04-08 1627
1、给定一个只包含括号（假设只包含‘（’和‘）’）的表达式，使用栈判断表达式中的括号是否匹配。 例如：（（）（（）））该式中括号匹配成功；（（（）（））该式中括号匹配失败。 2、舞伴问题。假设周末舞会上，男士们和女士们进入舞厅时各自排成一队。跳舞开始时，依次从男队和女队的队首各出列一名配成一对舞伴。若两队人数不同，则较长的那队中未配对的人等待下一首舞曲。是写一算法模拟上述配对问题。 注意：使用队列实现上述问题。可以有所扩展，譬如舞厅大小有限，每次只允许几组人跳舞，跳完之后可以继续排队，等待下一个舞曲等。本.
判断字符串中的括号是否匹配——c和c++实现
jusu10的博客
04-14 3984
判断字符串中的括号是否匹配 递归实现： 先检搜一对匹配的括号，再对里面的内容进行匹配，匹配完后再继续往下匹配…… 代码如下： #include <stdio.h> #include <stdlib.h> #include <string.h> // 在start与end中搜索匹配 int fun(char *str, int start, int ...
兰理鲲鹏-C语言简单的【栈和队列】（括号匹配问题）
qq_62852431的博客
04-13 3060
栈和队列轻松搞定
c语言给表达式加上括号,如何为中缀表达式加上完整的括号，有没有老哥有好办法?...
weixin_31750655的博客
05-22 524
该楼层疑似违规已被系统折叠隐藏此楼查看此楼1、逆波兰计算的时候，计算中加括号。2、语法树中序遍历加括号。写了个逻辑上等同于中序遍历的东西，BNF递归解析。支持个位数数字，+-*/()。#include #include #include #include using namespace std;enum node_type{OPERATOR,NUMBER,};typedef struct _no...
python学习一（基础语句）
qq_26226375的博客
07-26 944
开发环境“pycharm” python版本"3.7.3" 1.程序开始运行的地方 跟C语言不同，python代码是从上而下依次执行的，就跟bat脚本一样的。这里有一点需要注意，python的缩进符是会被判定为代码语句的。可以这么说，代码从没有缩进的代码开始执行。 例如： print("hello world") 执行结果如下： 如果在语句前边加入缩进符 print("hello world") 结果为: 这里就会报错。pthon中的缩进符就跟C语言中........
判断一个表达式中的括号是否配对，表达式已经存入字符数组 exp[]中
yyy_zxc的博客
03-06 532
#include<stdio.h> #include<malloc.h> //判断一个表达式中的括号是否配对 int match(char exp[],int n){ //传入存储表达式的数组以及数组长度 //定义、初始化一个顺序单链表 char stack[n]; int top = -1; int i; for(i=0;i<n;++i){ //在i++与++i同等作用下，一般使用++i，因为++i执行效率更高 if(exp[i] ==.
判断表达式中的括号是否匹配
qq_62860588的博客
03-25 5749
判断表达式中的括号是否匹配
c语言表达式中有多个括号,判断表达式中的括号是不是正确配对。求教
weixin_36277054的博客
05-18 1718
判断表达式中的括号是否正确配对。求教。假设表达式中允许包含三种括号：()、[]和{}。编写一个算法判断表达式中的括号是否正确配对。思路：设置一个括号栈，扫描表达式，遇到左括号时进栈，遇到右括号，若是相匹配的左括号，则出栈，否则返回0。若表达式扫描结束后，栈为空，返回1，表示括号正确匹配，否则返回0。哎！写不出来。有没有完整的代码额。------解决方案--------------------参考一...
（C语言）判断表达式中括号是否匹配-洋葱先生-杨少通
前端小白的逆袭
09-15 1973
注：本程序由Visual Studio 2015编写，与VC++6.0稍有区别，复制到VC++6.0注释掉“#include “stdafx.h””即可运行，复制到VS可直接运行。 #include “stdafx.h” #include <stdio.h> #include #include <string.h> using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -1 #define UNDERF
数据结构栈与队列中缀表达式求值算法
最新发布
10-22
根据提供的引用内容，数据结构中的栈和队列可以用来实现中缀表达式求值算法。中缀表达式是我们最为常见的表达式，运算符号位于参与运算的两个操作数中间的表达式称作中缀表达式。中缀表达式的求值算法可以通过将中缀...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值