数据结构第一次作业第二题（中缀表达式转化）

最新推荐文章于 2021-12-19 13:07:10 发布
最新推荐文章于 2021-12-19 13:07:10 发布
阅读量148 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MysteriousL/article/details/109002892
版权

在这里插入图片描述
数组栈

#include <stdio.h>
#include <stdlib.h>

typedef struct stack
{
    int top;
    char data[31];
} Stack;

typedef struct stack_num
{
    int top;
    float data[31];
} Stack_num;

void push(Stack *S, char x)
{
    if (S->top < 30)
    {
        S->data[++S->top] = x;
    }
    return;
}

void push_num(Stack_num *S, float x)
{
    if (S->top < 30)
    {
        S->data[++S->top] = x;
    }
    return;
}

char pop(Stack *S)
{
    if (S->top == -1)
    {
        return 0;
    }
    else
    {
        return S->data[S->top--];
    }
}

float pop_num(Stack_num *S)
{
    if (S->top != -1)
    {
        return S->data[S->top--];
    }
    return 0;
}

int main()
{
    Stack *S = (Stack *)malloc(sizeof(Stack));
    S->top = -1;
    char a[31];
    char b[31];
    gets(a);
    char temp;
    int i = 0, run = 0;
    while (a[i])
    {
        if (a[i] >= '0' && a[i] <= '9')
        {
            b[run++] = a[i];
            i++;
            continue;
        }
        if (S->top == -1)
        {
            push(S, a[i]);
        }
        else if (a[i] == '+' || a[i] == '-')
        {
            temp = S->data[S->top];
            while (temp != '(' && temp != 0)
            {
                temp = pop(S);
                if (temp != '(' && temp != ')' && temp != 0)
                    b[run++] = temp;
            }
            push(S, a[i]);
        }
        else if (a[i] == '*' || a[i] == '/')
        {
            temp = S->data[S->top];
            while (temp != 0 && temp != '(' && temp != '+' && temp != '-')
            {
                temp = pop(S);
                if (temp != 0 && temp != '(' && temp != ')')
                    b[run++] = temp;
            }
            push(S, a[i]);
        }
        else if (a[i] == '(')
            push(S, a[i]);
        else if (a[i] == ')')
        {
            temp = S->data[S->top];
            while (temp != 0 && temp != '(')
            {
                temp = pop(S);
                if (temp != 0 && temp != '(' && temp != ')')
                    b[run++] = temp;
            }
        }
        i++;
    }
    while (S->top != -1)
    {
        temp = pop(S);
        if (temp != 0 && temp != '(' && temp != ')')
        {
            b[run++] = temp;
        }
    }
    Stack_num *s = (Stack_num *)malloc(sizeof(Stack_num));
    s->top = -1;
    for (int k = 0; k < run; k++)
    {
        if (b[k] >= '0' && b[k] <= '9')
        {
            push_num(s, b[k] - '0');
        }
        else
        {
            float A = pop_num(s);
            float B = pop_num(s);
            if (b[k] == '+')
            {
                push_num(s, A + B);
            }
            else if (b[k] == '*')
            {
                push_num(s, A * B);
            }
            else if (b[k] == '/')
            {
                push_num(s, B / A);
            }
            else if (b[k] == '-')
            {
                push_num(s, B - A);
            }
        }
    }
    printf("%.2f\n", pop_num(s));
    for (int k = 0; k < run - 1; k++)
    {
        printf("%c ", b[k]);
    }
    printf("%c", b[run - 1]);
    return 0;
}

正确的链表栈

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

typedef struct Node
{
    char data;
    struct Node *next;
} LinkStack;

typedef struct stack
{
    float data[31];
    int top;
} Stack_num;

void push(LinkStack *S, char x);
char pop(LinkStack *S);
void push_num(Stack_num *S, float x);
float pop_num(Stack_num *S);
int Judge(int flag, char option);

int main()
{
    LinkStack *Stack = (LinkStack *)malloc(sizeof(LinkStack));
    Stack->next = NULL;
    char a[31];
    char b[31];
    gets(a);
    int i = 0, run = 0;
    while (a[i])
    {
        if (a[i] >= '0' && a[i] <= '9')
        {
            b[run++] = a[i];
            i++;
            continue;
        }
        while (!(Stack->next == NULL) && Judge(0, a[i]) < Judge(1, Stack->next->data))
            b[run++] = pop(Stack);
        if ((Stack->next == NULL))
        {
            push(Stack, a[i]);
            i++;
            continue;
        }
        else if (Judge(0, a[i]) > Judge(1, Stack->next->data))
        {
            push(Stack, a[i]);
        }
        else if (Judge(0, a[i]) == Judge(1, Stack->next->data))
        {
            pop(Stack);
        }
        i++;
    }
    while ((Stack->next != NULL))
    {
        b[run++] = pop(Stack);
    }
    b[run] = '\0';
    Stack_num *S = (Stack_num *)malloc(sizeof(Stack_num));
    S->top = -1;
    for (int k = 0; k < run; k++)
    {
        if (b[k] != '+' && b[k] != '-' && b[k] != '*' && b[k] != '/')
        {
            push_num(S, b[k] - '0');
        }
        else
        {
            float A = pop_num(S);
            float B = pop_num(S);
            //			printf("A=%f",A);
            //			printf("B=%f",B);
            if (b[k] == '+')
            {
                float put = A + B;
                push_num(S, put);
            }
            else if (b[k] == '-')
            {
                float put = B - A;
                push_num(S, put);
            }
            else if (b[k] == '*')
            {
                float put = A * B;
                push_num(S, put);
            }
            else if (b[k] == '/')
            {
                float put = B / A;
                push_num(S, put);
            }
        }
    }

    float print = pop_num(S);
    printf("%.2f\n", print);
    for (int o = 0; o < run - 1; o++)
    {
        printf("%c ", b[o]);
    }
    printf("%c", b[run - 1]);
    return 0;
}

void push(LinkStack *S, char x)
{
    LinkStack *p = (LinkStack *)malloc(sizeof(LinkStack));
    p->data = x;
    p->next = NULL;
    p->next = S->next;
    S->next = p;
}

char pop(LinkStack *S)
{
    if ((S->next != NULL))
    {
        LinkStack *temp = S->next;
        S->next = temp->next;
        char save = temp->data;
        free(temp);
        return save;
    }
    else
    {
        return '0';
    }
}

void push_num(Stack_num *S, float x)
{
    if (S->top + 1 < 31)
    {
        S->data[++S->top] = x;
    }
    else
    {
        return;
    }
}

float pop_num(Stack_num *S)
{
    if (S->top == -1)
    {
        return -1;
    }
    else
    {
        return S->data[S->top--];
    }
}

int Judge(int flag, char option)
{
    if (flag)
    {
        switch (option)
        {
        case '+':
            return 3;
        case '-':
            return 3;
        case '*':
            return 5;
        case '/':
            return 5;
        case '(':
            return 1;
        case ')':
            return 6;
        }
    }
    else
    {
        switch (option)
        {
        case '+':
            return 2;
        case '-':
            return 2;
        case '*':
            return 4;
        case '/':
            return 4;
        case '(':
            return 6;
        case ')':
            return 1;
        }
    }
}

逻辑运算版本

#include <stdio.h>
#include <stdlib.h>
#define maxsize 100
typedef struct Stack
{
    char data[maxsize];
    double numb[maxsize];
    int top;
    int bottom;
} Stack, *Pstack;

double getnum(char a, double b, double c);
void pop(Pstack s);
void push(Pstack s, char b);
void push2(Pstack s, double num);

int main()
{
    double num;
    char a[60];
    char b[60];
    for (int m = 0; m < 60; m++)
    {
        a[m] = b[m] = 0;
    }
    gets(a);
    //scanf("%s", a);
    Pstack f = (Pstack)malloc(sizeof(Stack));
    f->top = f->bottom = 0;
    int p = 0, q = 0;
    while (a[p] != 0)
    {
        if (a[p] >= '0' && a[p] <= '9')
        {
            b[q] = a[p];
            q++;
        }
        else
        {
            if (f->top == 0)
            {
                //f->top++;
                push(f, a[p]);
            }
            else
            {
                if (a[p] == '(')
                {
                    push(f, a[p]);
                }
                else if (a[p] == '+' || a[p] == '-')
                {
                    while (f->top != 0 && f->data[f->top] != '(')
                    {
                        b[q] = f->data[f->top];
                        q++;
                        pop(f);
                    }
                    push(f, a[p]);
                }
                else if (a[p] == '*' || a[p] == '/')
                {
                    while ((f->top != 0) && f->data[f->top] != '(' && f->data[f->top] != '+' && f->data[f->top] != '-')
                    {
                        b[q] = f->data[f->top];
                        q++;
                        pop(f);
                    }
                    push(f, a[p]);
                }
                else if (a[p] == ')')
                {
                    while (f->data[f->top] != '(')
                    {
                        b[q] = f->data[f->top];
                        q++;
                        pop(f);
                    }
                    pop(f);
                }
            }
        }
        p++;
    }
    while (f->top != 0)
    {
        b[q] = f->data[f->top];
        pop(f);
        q++;
    }

    Pstack s = (Pstack)malloc(sizeof(Stack));
    s->top = s->bottom = 0;
    int i = 0;
    while (b[i] != 0)
    {
        if (b[i] >= '0' && b[i] <= '9')
        {
            push2(s, b[i] - 48);
            num=b[i]-48;
        }
        else
        {
            num = getnum(b[i], s->numb[s->top], s->numb[s->top - 1]);
            pop(s);
            pop(s);
            push2(s, num);
        }
        i++;
    }
    printf("%.2lf\n", num);
    int m = 0;
    while (b[m] != 0)
    {
        printf("%c ", b[m]);
        m++;
    }
    return 0;
}
double getnum(char a, double b, double c)
{
    if (a == '+')
    {
        return c + b;
    }
    else if (a == '-')
    {
        return c - b;
    }
    else if (a == '*')
    {
        return b * c;
    }
    else if (a == '/')
    {
        return c / b;
    }
}
void pop(Pstack s)
{
    s->top--;
}
void push(Pstack s, char b)
{
    s->top++;
    s->data[s->top] = b;
}
void push2(Pstack s, double num)
{
    s->top++;
    s->numb[s->top] = num;
}
MysteriousL
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PTA:Tree Traversals Again(25分) C语言
睡觉不流口水 's blog
11-16 140
#include<stdio.h> #include<stdlib.h> typedef struct stack{ int stacksize; int *top; int *base; }stack; stack s; int preorder[30]; int inorder[30]; int n,flag=0; void getorder(int *preorder,int *inorder){ s.stacksize=20; s.b.
BJFU_数据结构习题_240基于栈的中缀算术表达式求值
雪地行进
10-26 5030
240基于栈的中缀算术表达式求值 描述 输入一个中缀算术表达式，求解表达式的值。运算符包括+、-、*、/、(、)、=，参加运算的数为double类型且为正数。（要求：直接针对中缀算术表达式进行计算，不能转换为后缀或前缀表达式再进行计算，只考虑二元运算即可。） 输入 多组数据，每组数据一行，对应一个算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。参加运算的数为double类...
用栈的思想来判断一个字符串是否是回文数
我和我的三只猫
11-13 3905
用栈的思想来判断一个字符串是否是回文数，如果是输出“yes”，，否则输出“no”。 这里其实就是，先将字符串的一半入栈，并计算它的长度（字符串一半的长度），然后将这两部分为字符串逐一比较 #include #include #include typedef struct Stack { int top; char str[100]; }Sqstack
结构体学习
Lucien的博客
12-19 205
3.1.认识结构体 #include <stdio.h> #include <string.h> struct Student { int sid; char name[200]; int age; }; //分号不能省略 int main(void) { struct Student st = {10, “zhangsan”, 20}; //st.name = “lass”; 错误，要用复制赋值 //strcpy(st.name, “lisi”); //st.sid = 13
在一个数组中实现两个堆栈 (20 分)
qq_43720467的博客
05-15 2671
在一个数组中实现两个堆栈 (20 分) 本题要求在一个数组中实现两个堆栈。 函数接口定义： Stack CreateStack( int MaxSize ); bool Push( Stack S, ElementType X, int Tag ); ElementType Pop( Stack S, int Tag ); 其中Tag是堆栈编号，取1或2；MaxSize堆栈数组的规模；Stack结...
利用栈判断回文数。
BANice的博客
09-01 5812
算法思路： 将字符串中全部字符进栈，然后将栈中的字符逐个与原字符串中的字符进行比较。#include using namespace std; typedef struct{ char data[1000]; int top; }Stack; void Init_stack(Stack *s) { s->top=0; } int Push_stack(Stack *s,char
2010-2011第二学期A卷（附答案）1
08-03
6. 后缀表达式（逆波兰表示法）是中缀表达式转化为可以无需括号就能进行计算的形式。中缀表达式“2*(3+4)-1”的后缀表达式是B选项，即2#3#4#+*1#-。 7. 环形队列的元素个数可以通过(rear-front+N)%N计算得出，考虑...
数据结构考试题(卷）2.doc
10-10
4. **栈的性质**：栈是后进先出（LIFO）的数据结构，因此在元素入栈和出栈的过程中，如果第一个出栈的元素是3（p1），那么第二个出栈的元素不可能是1（p2），因为1在3之前入栈。 5. **数据处理与栈**：栈是一种先进...
数据结构考试题.doc
09-29
以上是对数据结构考试题的部分解析，涵盖的数据结构和算法知识包括：非线性结构、时间复杂度分析、链表操作、栈和队列的特性、中缀表达式转后缀表达式、栈的应用、循环队列、矩阵压缩存储、树的性质、图论基础和最短...
第五次实验报告2
08-08
3. **堆栈（Stack）**：是一种先进后出（Last In First Out, LIFO）的数据结构，常用于处理后缀表达式转化为表达式树的问题。在这个实验中，我们用堆栈存储运算符和操作数，当遇到运算符时，取出堆栈顶部的两个操作...
C语言课程设计--输入一个表达式,输出其结果.pdf
11-06
程序的核心是将中缀表达式转化为后缀表达式（也称为逆波兰表示法），然后对后缀表达式进行计算。 1. **中缀转后缀算法**： - 首先，程序需要创建两个栈：一个用于存储操作数（OdStack，使用`double`类型）和一个...
0920编译原理词法分析
weixin_34116110的博客
09-20 96
#include<stdio.h> #include<stdlib.h> #include<string.h> #define _KEY_WOED_END "waiting for your expanding" //关键字结束标志 typedef struct { int typenum; char * word; }WOR...
《AI大模型应用》--迷你网页版 AI 聊天机器人，调用文心一言 API.zip
07-25
个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！
基于python的slaee管理系统 (27).zip
07-25
docker
IntelligentCompletionTrial.rar
07-25
IntelligentCompletionTrial
b186学生网上选课系统-springboot+vue.zip（可运行源码+sql文件+文档）
07-25
学生网上选课系统在对开发工具的选择上也很慎重，为了便于开发实现，选择的开发工具为Eclipse，选择的数据库工具为Mysql。以此搭建开发环境实现学生网上选课系统的功能。其中管理员管理用户，新闻公告。 学生网上选课系统是一款运用软件开发技术设计实现的应用系统，在信息处理上可以达到快速的目的，不管是针对数据添加，数据维护和统计，以及数据查询等处理要求，学生网上选课系统都可以轻松应对。 学生信息管理页面，此页面提供给管理员的功能有：学生信息的查询管理，可以删除学生信息、修改学生信息、新增学生信息，还进行了对用户名称的模糊查询的条件。排课信息管理页面，此页面提供给管理员的功能有：查看已发布的排课信息数据，修改排课信息，排课信息作废，即可删除，还进行了对排课信息名称的模糊查询 排课信息信息的类型查询等等一些条件。公告类型管理页面，此页面提供给管理员的功能有：根据公告类型进行条件查询，还可以对公告类型进行新增、修改、查询操作等等。公告信息管理页面，此页面提供给管理员的功能有：根据公告信息进行新增、修改、查询操作等等。
Matlab实现侏儒猫鼬优化算法DMO-TCN-Multihead-Attention多输入单输出回归预测算法研究.rar
07-25
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
b110果蔬作物疾病防治系统-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
07-25
本果蔬作物疾病防治系统分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理公告信息以及果蔬百科信息，能够与用户进行相互交流等操作，用户可以查看果蔬百科信息，可以查看公告以及查看管理员回复信息等操作。 该果蔬作物疾病防治系统采用的是WEB应用程序开发中最受欢迎的小程序结构模式，使用占用空间小但功能齐全的MySQL数据库进行数据的存储操作，系统开发技术使用到了Java技术。该果蔬作物疾病防治系统能够解决许多传统手工操作的难题，比如数据查询耽误时间长，数据管理步骤繁琐等问题。总的来说，果蔬作物疾病防治系统性能稳定，功能较全，投入运行使用性价比很高。 果蔬作物疾病防治系统分为管理员和用户两部分操作角色，管理员可以管理用户的基本信息，可以管理等功能。 蔬百科列表页面，此页面提供给管理员的功能有：查看果蔬百科、新增果蔬百科、修改果蔬百科、删除果蔬百科等。公告信息进行管理，可以新增公告信息,修改公告信息,删除无效的公告信息。公告类型管理页面显示所有公告类型，在此页面既可以让管理员添加新的公告信息类型，也能对已有的公告类型信息执行编辑更新，失效的公告类型信息也能让管理员快速删除。
GBT 2423.1-2008-试验A-低温
最新发布
07-25
GBT 2423.1-2008-试验A-低温
数据结构与算法解析：堆与中缀表达式转换
"该资源为一份关于数据结构和算法的PPT课件，重点讲述了如何用两个栈解决字符串处理中的中缀表达式计算问题，并涉及了堆数据结构及其相关操作，如插入和删除。" 在计算机科学中，算法是解决问题或执行任务的明确...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值