计算器处理程序（逆波兰）

最新推荐文章于 2023-01-13 19:48:35 发布
最新推荐文章于 2023-01-13 19:48:35 发布
阅读量164 收藏
点赞数
分类专栏： 吉首刷题路 文章标签： 逆波兰 C语言 计算器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43506138/article/details/84996441
版权
题目：读入一个只包含 +, -, *, / 的非负整数计算表达式，计算该表达式的值。Input测试输入包含若干测试用例，每个测试用例占一行，每行不超过200个字符，整数和运算符之间用一个空格分隔。没有非法表达式。当一行中只有0时输入结束，相应的结果不要输出。Output对每个测试用例输出1行，即该表达式的值，精确到小数点后2位。Sample Input1 + 24 + 2 * 5 ...
摘要由CSDN通过智能技术生成

题目：

读入一个只包含 +, -, *, / 的非负整数计算表达式，计算该表达式的值。
Input
测试输入包含若干测试用例，每个测试用例占一行，每行不超过200个字符，整数和运算符之间用一个空格分隔。没有非法表达式。当一行中只有0时输入结束，相应的结果不要输出。
Output
对每个测试用例输出1行，即该表达式的值，精确到小数点后2位。
Sample Input
1 + 2
4 + 2 * 5 - 7 / 11
0
Sample Output
3.00
13.36

分析：

此题，基本思路是将中缀表达式转化为后缀表达式。从而用压栈出栈的方式，进行处理。

#include"stdio.h"
#include"string.h"
#define MAX_lenght 10000
double atof1(char str[MAX_lenght])/*将字符串转化为double型的数*/
{
    double f,f1;
    int i,l;
    double n;
    l=strlen(str);
    f=0;
    f1=0;
    i=0;

    while(str[i]!='.'&&i<l)
    {
        f=f*10+(str[i]-'0');
        i++;
    }

    n=10;
    while(i<l)
    {
        f1=f1+(str[i]-'0')/n;
        n=n*10;
        i++;
    }
// printf("f=%0.2lf\n",f+f1);
    return f+f1;
}
typedef struct
{
    double data[MAX_lenght];
    int top;
} SqStack;//数字的存入。
typedef struct
{
    char data[MAX_lenght];
    int top;
} SqStackchar;//符号的存入
SqStack S;
SqStackchar Symbol;
void PUSHchar(char t)
{
    if(Symbol.top==MAX_lenght-1)
        printf("SqStack more ERROR\n");
    else
    {
        Symbol.top++;
        Symbol.data[Symbol.top]=t;

    }
}
void POPchar(char *t)
{
    if(Symbol.top==-1)
        printf("SqStackSymbol less ERROR\n");
    else
    {
        *t=Symbol.data[Symbol.top];
        Symbol.top--;
    }
}
void PUSH(double e)
{
    if(S.top==MAX_lenght-1)
        printf("SqStack more ERROR\n");
    else
    {
        S.top++;
        S.data[S.top]=e;

    }
}
void POP(double *e)
{
    if(S.top==-1)
        printf("SqStack less ERROR\n");
    else
    {
        *e=S.data[S.top];
        S.top--;
    }
}
int main()
{
    char c,t,SM;
    double e,a,b;
    char str[MAX_lenght];
    int i,q;

    /*   这里是一开始模拟后缀表达式的计算过程所写的
    scanf("%c",&c);
    while(c!='#')
    {
        while(c>='0'&&c<='9')//这里是对数字的处理过程，将一个数字转化为double型
        {
            str[i++]=c;
            str[i]='\0';
            scanf("%c",&c);
            if(c==' ')//该数字结束
            {
                e=atof1(str);

                PUSH(e);
                i=0;
                break;
            }
        }

        switch(c)//四则运算
        {
        case '+':
            POP(&a);
            POP(&b);
            PUSH(a+b);
            break;
        case '-':
            POP(&a);
            POP(&b);
            PUSH(b-a);
            break;
        case '*':
            POP(&a);
            POP(&b);
            PUSH(a*b);
            break;
        case '/':
            POP(&a);
            POP(&b);
            if(a==0)
            {
                printf("a=0了，除数不能为0；\n");
                return -1;
            }
            else
                PUSH(b/a);
            break;
        }
        scanf("%c",&c);
    }
    POP(&a);
    printf("%0.2lf\n",a);
    */
    q=0;
    while(1)//多组
    {
         S.top=-1;
         Symbol.top=-1;
         i=0;
    scanf("%c",&c);
    if(c=='0')/*这里是需要判断是否第一个为0且这一行只有一个0。则程序结束。需要注意的是不能直接break。因为，这一会如果不止一个0的话，程序是不能结束的。*/
        q=1;
    while(c!='\n')//到达换行则一组数据结束。
    {
        while(c>='0'&&c<='9')//这里是对数字的处理过程，将一个数字转化为double型
        {
            str[i++]=c;
            str[i]='\0';
            scanf("%c",&c);
            if(c==' '||c=='\n')//该数字结束
            {
                e=atof1(str);

                PUSH(e);
                i=0;
                break;
            }
        }//1 + 2 + 3 #
        switch(c)//对四个符号的处理。
        {
        case  '+':
            {
            SM=0;
            while(Symbol.top!=-1)//如果不是第一个符号了， 则需要将之前的符号取出进行运算
            {     POPchar(&SM);
                  if(SM=='(')
                        break;
                switch(SM)//四则运算
                {
                case '+':
                    POP(&a);
                    POP(&b);
                    PUSH(a+b);
                    break;
                case '-':
                    POP(&a);
                    POP(&b);
                    PUSH(b-a);
                    break;
                case '*':
                    POP(&a);
                    POP(&b);
                    PUSH(a*b);
                    break;
                case '/':
                    POP(&a);
                    POP(&b);
                    if(a==0)
                    {
                        printf("a=0了，除数不能为0；\n");
                        return -1;
                    }
                    else
                        PUSH(b/a);
                    break;
                }



            }
            if(SM=='(')//如果是因为SM=‘（‘退出的，SM是还需要的进栈的。
                PUSHchar(SM);
            PUSHchar(c);
        }
        break;
        case '-':
           {SM=0;
            while(Symbol.top!=-1)
            {   POPchar(&SM);
                  if(SM=='(')
                        break;
                switch(SM)//四则运算
                {
                case '+':
                    POP(&a);
                    POP(&b);
                    PUSH(a+b);
                    break;
                case '-':
                    POP(&a);
                    POP(&b);
                    PUSH(b-a);
                    break;
                case '*':
                    POP(&a);
                    POP(&b);
                    PUSH(a*b);
                    break;
                case '/':
                    POP(&a);
                    POP(&b);
                    if(a==0)
                    {
                        printf("a=0了，除数不能为0；\n");
                        return -1;
                    }
                    else
                        PUSH(b/a);
                    break;
                }

            }
            if(SM=='(')
                PUSHchar(SM);
            PUSHchar(c);
            }
            break;
        case '*':
        {   SM=0;
            while(Symbol.top!=-1)
            { POPchar(&SM);
                  if(SM=='('||SM=='+'||SM=='-')
                        break;
                switch(SM)//四则运算
                {
                case '+':
                    POP(&a);
                    POP(&b);
                    PUSH(a+b);
                    break;
                case '-':
                    POP(&a);
                    POP(&b);
                    PUSH(b-a);
                    break;
                case '*':
                    POP(&a);
                    POP(&b);
                    PUSH(a*b);
                    break;
                case '/':
                    POP(&a);
                    POP(&b);
                    if(a==0)
                    {
                        printf("a=0了，除数不能为0；\n");
                        return -1;
                    }
                    else
                        PUSH(b/a);
                    break;
                }

            }
            if(SM=='('||SM=='-'||SM=='+')
                PUSHchar(SM);
            PUSHchar(c);
            }
            break;
        case '/':
            {SM=0;
             while(Symbol.top!=-1)
            {POPchar(&SM);
                  if(SM=='('||SM=='+'||SM=='-')
                        break;
                switch(SM)//四则运算
                {
                case '+':
                    POP(&a);
                    POP(&b);
                    PUSH(a+b);
                    break;
                case '-':
                    POP(&a);
                    POP(&b);
                    PUSH(b-a);
                    break;
                case '*':
                    POP(&a);
                    POP(&b);
                    PUSH(a*b);
                    break;
                case '/':
                    POP(&a);
                    POP(&b);
                    if(a==0)
                    {
                        printf("a=0了，除数不能为0；\n");
                        return -1;
                    }
                    else
                        PUSH(b/a);
                    break;
                }

            }
            if(SM=='('||SM=='-'||SM=='+')
                PUSHchar(SM);
            PUSHchar(c);}
            break;
        case ')':
            {
            while(Symbol.top!=-1)
            {  POPchar(&SM);
                  if(SM=='(')
                        break;
                switch(SM)//四则运算
                {
                case '+':
                    POP(&a);
                    POP(&b);
                    PUSH(a+b);
                    break;
                case '-':
                    POP(&a);
                    POP(&b);
                    PUSH(b-a);
                    break;
                case '*':
                    POP(&a);
                    POP(&b);
                    PUSH(a*b);
                    break;
                case '/':
                    POP(&a);
                    POP(&b);
                    if(a==0)
                    {
                        printf("a=0了，除数不能为0；\n");
                        return -1;
                    }
                    else
                        PUSH(b/a);
                    break;
                }

            }
         //   PUSHchar(c); 1 + 2 * ( 5 - 3 ) #
            }
            break;

        }
       if(c=='(')
         {PUSHchar(c);

         }
     if(c=='\n')
        break;
     scanf("%c",&c);

    }
          if(Symbol.top==-1&&S.top==0&&q==1)/*这里是判断是否是第一个0且这行只有一个0的情况*/
             break;
            while(Symbol.top!=-1)//将符号栈中的符号取出，进行运算。
            { POPchar(&SM);

                switch(SM)//四则运算
                {
                case '+':
                    POP(&a);
                    POP(&b);
                    PUSH(a+b);
                    break;
                case '-':
                    POP(&a);
                    POP(&b);
                    PUSH(b-a);
                    break;
                case '*':
                    POP(&a);
                    POP(&b);
                    PUSH(a*b);
                    break;
                case '/':
                    POP(&a);
                    POP(&b);
                    if(a==0)
                    {
                        printf("a=0了，除数不能为0；\n");
                        return -1;
                    }
                    else
                        PUSH(b/a);
                    break;
                }

            }
        POP(&a);//将结果取出

     printf("%0.2lf\n",a);



}

}
年轻过成了秃顶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RustCalc:一个基本的波兰符号计算器
07-17
生锈计算器 RustCalc 是波兰语符号计算器（参见 ）。 这意味着您必须先编写操作，然后再编写参数，例如(+ 2 3)或(- 10 (* 2 6) 5) 。 这样做的原因是更容易解析。 跑步 cargo run --release 目标 看到，我认为用 Rust 编写一个小计算器是个好主意。 但是，我的重点主要放在制作解析器和生成 AST（抽象语法树）上，而不是拥有一个好的计算器，所以不要期望诸如任意精度之类的功能。 我是从头开始写的，试图用惯用的方式来写，所以我希望它对想要学习 Rust 的人也有用。 特征 完成解析器后，我认为用一些功能增强计算器会很有趣。 这些是其中一些： 预定义函数（ sqrt和pow ）。 示例： (pow 2 8) 。 预定义常量（ pi和e ）。 示例： (* pi 2) 。 用户定义的变量。 示例： (set myVar 42) , (+ myV
波兰计算器
yyhhccc的博客
02-01 242
波兰计算器 中缀表达式转换为后缀： 初始化两个栈：运算符栈s1 和储存中间结果的栈s2； 从左至右扫描中缀表达式； 遇到操作数时，将其压s2； 遇到运算符时，比较其与s1 栈顶运算符的优先级： 1.如果s1 为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈； 2.否则，若优先级比栈顶运算符的高，也将运算符压入s1； 3.否则，将s1 栈顶的运算符弹出并压入到s2 中，再次转到(4-1)与s1 中新的栈顶运算符相比较； 遇到括号时： (1) 如果是左括号“(”，则直接压入s1 (2) 如果是右括号“)
波兰式计算器
无知的我
07-09 1759
11.波兰式计算器成绩: 15 / 折扣: 0.8背景 以下是几个标准的表达式： 5 * 2 + -3 5 * (2 + -3) 5 + ((-4 * -5) + (((5 + (6 - 2)) * 7 + ((4 + 2) * (3 - 1)))) 与之等价的波兰表达式为 +
波兰计算器和逆波兰计算器
qq_45772965的博客
01-28 461
波兰计算器和逆波兰计算器 波兰表达式   波兰表达式也称前缀表达式，他是运算符写在数字的前边一种表达式。 举个例子，比如一般表达式，也就是前缀表达式 (15 + 4) * 5 - 6 (15 + 4) 的波兰表达式为 15  4 + (15 + 4) * 5 的波兰表达式为 15  4 + 5 * (15 + 4) * 5 - 6 的波兰表达式为 15  4 + 5 * 6 - 逆波兰表达式   逆波兰表达式也称后缀表达式，他是运算符写在数字的后边一种表达式。 还是上面那
简易逆波兰计算器
qq_40691113的博客
11-21 207
package com.stack; import java.text.DecimalFormat; import java.util.ArrayList; import java.util.List; import java.util.Stack; //逆波兰计算器 /* * 计算器主要方法：1计算器中缀转后缀 * 思路： * ...
Android 计算器源码之逆波兰算法
05-02
总结来说，逆波兰算法在Android计算器应用中的实现是一个典型的编程问题，涉及到字符串处理、数据结构（堆栈）的运用以及数学逻辑的实现。通过这种方式，我们可以构建一个功能强大的计算器应用，能够处理复杂的数学...
简易灰色逆波兰表达式计算器代码
06-11
逆波兰表达式（Reverse Polish Notation，RPN）是一种没有括号且运算符放在操作数之后的数学表达式表示方式，常用于计算器设计。在这个简易的灰色逆波兰表达式计算器中，我们主要涉及以下几个关键知识点： 1. **逆...
基于逆波兰式计算器
04-02
逆波兰式计算器是一种基于后缀表达式的计算工具，它在计算机科学中被广泛用于解析和求解数学表达式。在本项目中，我们利用Visual Studio（VS）和Microsoft Foundation Classes (MFC)库来构建一个具有图形用户界面...
逆波兰式计算器
06-15
2. **表达式解析**：程序需要能够识别输入的逆波兰式表达式，将其中的数字和运算符分离出来，逐个处理。 3. **基本数学运算**：包括加、减、乘、除等基本算术运算，以及如tan（正切）这样的三角函数运算。 4. **...
QT-科学计算器-可视化-逆波兰算法
03-28
在这个项目中，“QT-科学计算器-可视化-逆波兰算法”显然是一个使用QT框架构建的高级计算器应用，它提供了丰富的数学功能，如处理括号表达式、解决二元一次方程、执行指数和对数运算等。 首先，让我们深入了解一下...
数据结构实现计算器 （完整，代码程序）
10-10
数据结构，计算器，非常好，适合学习，进步等等！
简单逆波兰计算器
doodlesomething
08-21 1674
目标是编写一个具有加(+) 、减(-)、乘(*)、除(/)四则运算功能的计算器程序。为了更容易实现,我们在计算器中使用 逆波兰表示法代替普通的中辍表示法 (逆波兰表示法用在某些袖珍计算器中, Forth 与 Postscript 等语言也使用了逆波兰表示法
java实现逆波兰表（后缀）达式计算器（注释超详细）
qq_38099207的博客
06-16 303
如果不知道什么是前缀、中缀、后缀表达式的请参考此博客 https://blog.csdn.net/Antineutrino/article/details/6763722 1、将中缀表达式转换成列表，方便运算 /** * 将表达式放进list * @param expression * @return 中缀表达式列表 */ public List&...
逆波兰计算器
最新发布
南瓜籽_的博客
01-13 598
Java实现逆波兰计算器
【数据结构与算法(java)】逆波兰计算器
m0_66379610的博客
07-27 251
如果想要进行小数运算可增添小数点拼接，将int返回值与变量改为double，用正则表达式匹配数字(代码内有）计算器为逆波兰计算器，支持整数运算。
【数据结构13】逆波兰计算器
你今天真好看呀
12-27 288
文章目录1. 波兰表达式（前缀表达式）2. 中缀表达式3. 逆波兰表达式（后缀表达式）4. 逆波兰计算器 1. 波兰表达式（前缀表达式） 2. 中缀表达式 3. 逆波兰表达式（后缀表达式） 4. 逆波兰计算器 public class PolanNotation { public static void main(String[] args) { //先定义逆波...
逆波兰计算器加强版：多项式
weixin_30906671的博客
03-22 99
不说了不说了，，， 链表感觉白学了（学了吗？）= = 鲍鱼鲍鱼。。。。哇哇哇 http://paste.ubuntu.com/15464514/ //cww 多项式计算器 #include<stack> #include<cstdio> #include<iostream> using namespace ...
逆波兰计算器完整版
实践求真知
03-06 192
一需求 完整版的逆波兰计算器，功能包括如下： 1 支持 + - * / ( ) 2 多位数，支持小数 3 兼容处理, 过滤任何空白字符，包括空格、制表符、换页符 二代码 import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Stack; import java.util.regex.Pattern; /** * @className: Rever..
表达式计算器（逆波兰法）栈操作（C语言实现）
热门推荐
Zxn、Sirius荣耀之路
04-07 1万+
可能很多的同学在学数据结构的时候。说到栈，都会有一道很经典的题目，那就是用栈来实现计算器。我们都知道普通的计算写起来是很简单的，但是如果涉及到左右括号以及加减乘除组成的运算式的时候则写起程序时便不那么容易了。 比如：（1+（2*（1+3）/2）+10) 面对上面这个表达式，要想写出这样一个计算器的程序就显得比较困难，有一种先进后出的数据结构———栈就可以很好的解决这个问题。那么是不是我们有了栈之
Java编程：构建计算器程序
7. **栈结构**：为了处理运算符的优先级，可以使用栈来存储运算符和中间结果，这是一种经典的“后缀表达式”或“逆波兰表示法”算法。 8. **控制流**：根据运算符的优先级，控制流需要能够正确地跳转和处理嵌套的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值