后缀表达式

最新推荐文章于 2021-07-30 19:23:45 发布
最新推荐文章于 2021-07-30 19:23:45 发布
阅读量493 收藏
点赞数
分类专栏： 算法分享 文章标签： c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013422712/article/details/41251009
版权
or:rgb(0,0,0);font-style:normal;font-v ★实验任务热爱数学的小明在学习算式， 他发现算式的表达不止一种， 有一种叫做后缀表达式， 而我们平常使用的是中缀表达式（a+b 是中缀表达式， 而 ab+是后缀表达式），现在小明想对一些中缀表达式计算出他们的后缀表达式， 并通过后缀表达式计算出值，你能帮助他吗？
★数据输入读入一个只包含 +, -, *, / ， （， ） 的非负整数计算表达式，该表达式的后缀表达式。每个输入为一行字符串， 字符串长度不超过 100000，整数和运算符之间用一个空格分隔。没有非法表达式。
★数据输出对于每个输入， 输出 2 行， 第一行即该表达式的后缀表达式， 数与数之间、 符号与数之间、符号与符号之间都应有一个空格隔开（注意行末无空格），第二行是该算式的值， 精确到小数点后 2 位。

输入示例         输出示例

681 + 62 - 83     681 62 + 83-
                  660.00

 
 
             #include <stdio.h>   
#include <stdlib.h>   
#include <malloc.h>   
#include <ctype.h>   
 
#define STACK_INIT_SIZE 100000   
#define STACKINCREMENT  10   
#define MAXBUFFER       20   
 
typedef char BaseType,BaseType1;   
typedef double ElemType;   
typedef struct  
{   
    BaseType *base;   
    BaseType *top;   
    int stackSize;   
}aStack;   
 
typedef struct  
{   
    BaseType1 *base;   
    BaseType1 *top;   
    int stackSize;   
}aStack1;   
 
typedef struct  
{   
    ElemType *base;   
    ElemType *top;   
    int stackSize;   
}sqStack;   
 
void StackInit(aStack *s);   
void Push(aStack *s,BaseType b);   
void Pop(aStack *s,BaseType *b);   
int StackLen(aStack s);   
 
void StackInit1(aStack1 *s);   
void Push2(aStack1 *s,BaseType1 b);   
void Pop2(aStack1 *s,BaseType1 *b);   
int StackLen2(aStack1 s);   
 
void InitStack(sqStack *s);   
void Push1(sqStack *s,ElemType b);   
void Pop1(sqStack *s,ElemType *b);   
int StackLen1(sqStack s);   
 
int main()   
{   
    aStack s;   
    sqStack q;   
    aStack1 r;   
    char c,e;   
    char str[MAXBUFFER];   
    double d,f;   
    int i=0;   
    StackInit(&s);   
    InitStack(&q);   
    StackInit1(&r);   
 
    scanf("%c",&c);   
    while(c!='\n')   
    {   
        while(c>='0'&&c<='9')   
        {   
            Push2(&r,c);   
            printf("%c",c);   
            scanf("%c",&c);   
            if(c<'0'||c>'9')   
            {   
                Push2(&r,' ');   
                printf(" ");   
            }   
        }   
        if(c==')')   
        {   
            Pop(&s,&e);   
            while(e!='(')   
            {   
                Push2(&r,e);   
                Push2(&r,' ');   
                printf("%c ",e);   
                Pop(&s,&e);   
            }   
        }   
        else if(c=='+'||c=='-')   
        {   
            if(!StackLen(s))   
            {   
                Push(&s,c);   
            }   
            else  
            {   
                do  
                {   
                    Pop(&s,&e);   
                    if(e=='(')   
                    {   
                        Push(&s,e);   
                    }   
                    else  
                    {   
                        Push2(&r,e);   
                        Push2(&r,' ');   
                        printf("%c ",e);   
                    }   
                }while(StackLen(s)&&e!='(');   
                    Push(&s,c);   
            }   
        }   
        else if(c=='(')   
        {   
            Push(&s,c);   
        }   
        else if(c=='*'||c=='/')   
        {   
            if(!StackLen(s))   
            {   
                Push(&s,c);   
            }   
            else  
            {   
                Pop(&s,&e);   
                if(e=='*'||e=='/')   
                {   
                    Push2(&r,e);   
                    Push2(&r,' ');   
                    printf("%c ",e);   
                }   
                else  
                {   
                    Push(&s,e);   
                }   
                Push(&s,c);   
            }   
        }   
        else if(c=='\n')   
            break;   
        scanf("%c",&c);   
    }   
    while(StackLen(s))   
    {   
        Pop(&s,&e);   
        Push2(&r,e);   
        Push2(&r,' ');   
        printf("%c ",e);   
    }   
    e='#';   
    Push2(&r,e);   
    while(StackLen2(r))   
    {   
        Pop2(&r,&c);   
        Push(&s,c);   
    }   
    Pop(&s,&c);   
    while(c!='#')   
    {   
        while(isdigit(c))   
        {   
            str[i++]=c;   
            str[i]='\0';   
            Pop(&s,&c);   
            if(c==' ')   
            {   
                d=atof(str);   
                Push1(&q,d);   
                i=0;   
                break;   
            }   
        }   
        switch(c)   
        {   
        case'+':   
            Pop1(&q,&f);   
            Pop1(&q,&d);   
            Push1(&q,d+f);   
            break;   
        case'-':   
            Pop1(&q,&f);   
            Pop1(&q,&d);   
            Push1(&q,d-f);   
            break;   
        case'*':   
            Pop1(&q,&f);   
            Pop1(&q,&d);   
            Push1(&q,d*f);   
            break;   
        case'/':   
            Pop1(&q,&f);   
            Pop1(&q,&d);   
            Push1(&q,d/f);   
            break;   
        }   
        Pop(&s,&c);   
    }   
    Pop1(&q,&d);   
    printf("\n%.2f",d);   
    return 0;   
}   
 
void StackInit(aStack *s)   
{   
    s->base=(BaseType *)malloc(STACK_INIT_SIZE*sizeof(BaseType));   
    if(!s->base)   
        exit(0);   
    s->top=s->base;   
    s->stackSize=STACK_INIT_SIZE;   
}   
 
void Push(aStack *s,BaseType b)   
{   
    if(s->top-s->base>=s->stackSize)   
    {   
        s->base=(BaseType *)realloc(s->base,(s->stackSize+STACKINCREMENT)*sizeof(BaseType));   
        if(!s->base)   
            exit(0);   
    }   
    *(s->top)=b;   
    s->top++;   
}   
 
void Pop(aStack *s,BaseType *b)   
{   
    if(s->top==s->base)   
        return;   
    *b=*--(s->top);   
}   
 
int StackLen(aStack s)   
{   
    return(s.top-s.base);   
}   
 
void StackInit1(aStack1 *s)   
{   
    s->base=(BaseType1 *)malloc(STACK_INIT_SIZE*sizeof(BaseType1));   
    if(!s->base)   
        exit(0);   
    s->top=s->base;   
    s->stackSize=STACK_INIT_SIZE;   
}   
 
void Push2(aStack1 *s,BaseType1 b)   
{   
    if(s->top-s->base>=s->stackSize)   
    {   
        s->base=(BaseType1 *)realloc(s->base,(s->stackSize+STACKINCREMENT)*sizeof(BaseType1));   
        if(!s->base)   
            exit(0);   
    }   
    *(s->top)=b;   
    s->top++;   
}   
 
void Pop2(aStack1 *s,BaseType1 *b)   
{   
    if(s->top==s->base)   
        return;   
    *b=*--(s->top);   
}   
 
int StackLen2(aStack1 s)   
{   
    return(s.top-s.base);   
}   
 
void InitStack(sqStack *s)   
{   
    s->base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));   
    if(!s->base)   
        exit(0);   
    s->top=s->base;   
    s->stackSize=STACK_INIT_SIZE;   
}   
 
void Push1(sqStack *s,ElemType b)   
{   
    if(s->top-s->base>=s->stackSize)   
    {   
        s->base=(ElemType *)realloc(s->base,(s->stackSize+STACKINCREMENT)*sizeof(ElemType));   
        if(!s->base)   
            exit(0);   
    }   
    *(s->top)=b;   
    s->top++;   
}   
 
void Pop1(sqStack *s,ElemType *b)   
{   
    if(s->top==s->base)   
        return;   
    *b=*--(s->top);   
}   
 
int StackLen1(sqStack s)   
{   
    return(s.top-s.base);   
}
       

   



Intelige
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
后缀表达式求值
诗和远方，代码和你
06-22 3056
问题 H: 后缀表达式求值 时间限制: 1 Sec 内存限制: 128 MB 提交: 1042 解决: 460 [提交][状态][讨论版] 题目描述 为了便于处理表达式，常常将普通表达式（称为中缀表示）转换为后缀{运算符在后，如X/Y写为XY/表达式。在这样的表示中可以不用括号即可确定求值的顺序，如：(P+Q)(R－S) → PQ+RS－。后缀表达式的处理过程如下：扫描后缀表达式，凡遇
后缀表达式／中缀到后缀表达式
物极必反否极泰来
08-27 373
输入空格跳出循环 while((k=getchar())!='\n') { a[i]=k; i++; }
[栈操作] [洛谷] P1449 后缀表达式
Zeolim的博客
07-31 321
  这道题上来没啥思路 也读不懂题 有天听巨巨说是个栈操作 然后又放了几天     突然就把题读懂了 知道是个栈就特别简单了… 注意运算顺序就行   #include &lt;iostream&gt; #include &lt;stack&gt; using namespace std; typedef long long ll; int main() { ...
7-42 小明的计算题 (50分)
Rita的博客
02-09 2232
小明酷爱数学，因为数学实在是太有趣了，因此他天天做数学题，但是聪明的小明也是会遇到困难的。有一天他的山老师题出了一个问题：一个集合存在n个数，请问集合中有多少个数，恰好等于集合中另外两个数之和？小明想不到方法，只能一个一个计算，但是着实在太麻烦了，他知道你已经做出来这道题，所以向你发出了求救请求，用代码帮助小明解决此问题。 输入格式: 输入一个数字n,(0=<n<=100)表示集合中数...
数据结构-实验3-后缀表达式求值.doc
07-11
后缀表达式，又称逆波兰表示法，是一种不使用括号的数学表达式表示方法，主要依靠运算符出现在操作数之后这一特性来确定运算顺序。在计算机科学中，后缀表达式常用于利用栈实现表达式的求值。在这个实验中，目标是...
后缀表达式相关，包括中缀表达式转后缀表达式以及后缀表达式的运算
01-10
（1） 从键盘或文件读入一个合法的算术表达式，输出相应的后缀表达式。后缀表达式中，数据与数据之间加分隔符； （2） 输出正确的计算结果，保留两位小数点； （3） 考虑算法的健壮性，当表达式错误时，要给出错误...
中缀表达式转换为后缀表达式（oj题库）
12-21
中缀表达式转换为后缀表达式是一种常见的编程问题，主要应用于计算机算法解析和计算领域。后缀表达式，也称为逆波兰表示法，是一种没有括号的表达方式，运算符位于其操作数之后，这使得计算过程更为简单，因为不需要...
自定义栈中缀表达式转换为后缀表达式并求值
05-20
### 自定义栈中缀表达式转换为后缀表达式并求值 #### 需求分析与背景 在计算机科学领域，将一个中缀表达式转换为后缀表达式是解决算术表达式求值问题的一种常用方法。通过这种方式可以避免括号带来的优先级问题，...
包含中缀表达式转后缀表达式以及后缀表达式求值
最新发布
06-20
后缀表达式，也称为逆波兰表示法，是一种在计算表达式时避免使用括号的表示方式。在后缀表达式中，运算符位于其操作数之后，这使得表达式的计算变得更为简单，特别适用于算法实现。这个压缩包文件"SuffixToValue-...
表达式的计算（后缀表达式的求解）
二哈
02-18 2万+
1. 问题网址：http://lx.lanqiao.cn/problem.page?gpid=T419 问题描述： 问题描述 　　输入一个只包含加减乖除和括号的合法表达式，求表达式的值。其中除表示整除 输入格式 　　输入一行，包含一个表达式 输出格式 　　输出这个表达式的值 样例输入 1-2+3*(4-5) 样例输出 -4 数据规模和约定 　　表达式长度不超过100，...
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。
qq_29462849的博客
07-05 930
题目介绍 小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck! 题目分析 这是一个典型的以某个数字点为起点，...
中缀表达式转换为后缀表达式
热门推荐
__七把刀__
09-20 17万+
一、后缀表达式求值 后缀表达式也叫逆波兰表达式，其求值过程可以用到栈来辅助存储。假定待求值的后缀表达式为：6  5  2  3  + 8 * + 3  +  *，则其求值过程如下： 1）遍历表达式，遇到的数字首先放入栈中，此时栈如下所示： 2）接着读到“+”，则弹出3和2，执行3+2，计算结果等于5，并将5压入到栈中。 3）读到8，将其直接放入栈中。 4）读到“*”，弹出8和
后缀表达式看完这一篇文章就理解了！
a8425的博客
07-30 8万+
宝、⁄(⁄ ⁄•⁄ω⁄•⁄ ⁄)⁄ 后缀表达式是栈的运用，如果你还不知道栈是什么，那请你先去看看关于栈的文章 文章目录 一、什么是后缀表达式 二、后缀表达式的运算顺序 三、中缀表达式 四、中缀表达式转化为后 缀表达式 一、什么是后缀表达式 后缀表达式是一种不需要括号的表达式。 对于四则运算，我们用括号来规定了它的运算顺序。 但是在早些年对于计算机，并没有括号来规定其运算顺序。 当没有了括号 比如想要输入 9+（3-1）x3+10/2 当没有了括号会怎么样呢， ..
C++编程：中缀表达式转后缀表达式算法实现
"C++利用栈实现中缀表达式转后缀表达式" 在计算机科学中，中缀表达式和后缀表达式是两种表示算术表达式的方式。中缀表达式是我们通常所熟悉的，例如 "1 + (2 - 3) * 4 + 10 / 5"，其中运算符位于操作数之间。后缀...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值