输入表达式计算表达式的值（java）

最新推荐文章于 2024-07-13 02:52:20 发布
最新推荐文章于 2024-07-13 02:52:20 发布
阅读量2.5k 收藏 18
点赞数
文章标签： java 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45377857/article/details/117391321
版权

问题描述：

输入一个计算表达式，计算该表达式的值。表达式复杂度分为两级：第一级：加减乘除；
第二级：包含sin、cos、tgn、sqrt、exp、pow函数

*解决思路

1.设置两个栈，一个用于存放操作数，一个用于存放运算符

private static Stack<Double> vals = new Stack<Double>();
    private static Stack<Character> ops = new Stack<Character>();

2.基于后缀表达式设计，从左往右遍历字符数组，遇到数字入栈，遇到’('以及一些特殊函数预算符入栈。这里sin用’s’代替入栈，cos用’c’代替……

if(i + 4 <= ch.length){
                String str1 = new String(ch,i,3);
                String str2 = new String(ch,i,4);
                if(str1.equals("sin")) {
                    ops.push(ch[i]);//s表示sin
                    i+=3;
                }else if(str1.equals("cos")){
                    ops.push(ch[i]);//c表示cos
                    i+=3;
                }else if(str1.equals("tan") || str1.equals("tgn")){
                    ops.push(ch[i]);//t表示tan函数
                    i+=3;
                }else if(str1.equals("exp")){
                    ops.push(ch[i]);//e表示指数函数
                    i+=3;
                }else if(str2.equals("sqrt")){
                    ops.push('q');//q表示开方
                    i +=4;
                }
            }

3.若扫描到数字，则数字入栈（这里特别注意负数的处理,以及浮点数的处理）

			if(ch[i] == '-' && (vals.empty() || ops.lastElement() == '(')){
                isNegative = true;//判断是否为负数
                i ++;
            }
            if ((ch[i] >= '0' && ch[i] <= '9') || ch[i] == '.') {
                double val = 0;
                double temp = 1;
                boolean byPoint = false;
                while ((ch[i] >= '0' && ch[i] <= '9') || ch[i] == '.') {
                    if (ch[i] == '.') {
                        i++;
                        byPoint = true;
                        temp = 10;
                        continue;
                    }
                    if (byPoint) {
                        int x = (int) ch[i] - 48;
                        val += ((double) x) / temp;
                        temp = temp * 10;
                        i++;

                    } else {
                        int x = (int) ch[i] - 48;
                        val = val*10 + x;
                        i++;
                    }
                }
                if(isNegative) val = -1*val;
                vals.push(val);
                continue;
            }

4.扫描到运算符，则弹出栈里更高级或者同级的运算符，这里特别注意特殊函数的运算级别最高，而且遇见特殊函数只弹出一个操作数。

else if(ch[i] == '+' || ch[i] == '-' || ch[i] == '*'|| ch[i] == '/'||ch[i] == '^'){
                char t = ch[i];
                char c;
                switch (t){
                    case '+':
                    case '-':
                        c = ops.pop();
                       while (c != '(' && c != '#'){
                           double r;
                           double l;
                           if(c == '+'){
                               r = vals.pop();
                               l = vals.pop();
                               vals.push(l + r);
                           }else if(c == '-'){
                               r = vals.pop();
                               l = vals.pop();
                               vals.push(l - r);
                           }else if(c == '*'){
                               r = vals.pop();
                               l = vals.pop();
                               vals.push(l*r);
                           }else if(c == '/'){
                               r = vals.pop();
                               l = vals.pop();
                               vals.push(l/r);
                           }else if(c == '^'){
                               r = vals.pop();
                               l = vals.pop();
                               vals.push(pow(l,r));
                           }else if(c == 'q'){
                               r = vals.pop();
                               vals.push(sqrt(r));
                           } else if (c == 's') {
                               r = vals.pop();
                               vals.push(sin(r));
                           }else if(c == 'c'){
                               r = vals.pop();
                               vals.push(cos(r));
                           }else if(c == 't'){
                               r = vals.pop();
                               vals.push(tan(r));
                           }else if(c == 'e'){
                               r = vals.pop();
                               vals.push(exp(r));
                           }
                           c = ops.pop();


                       }
                       ops.push(c);
                       ops.push(ch[i]);
                       i++;
                       break;
                    case '*':
                    case '/':
                        c = ops.pop();
                        while (c != '(' && c != '#' && c != '+' && c != '-'){
                            double r;
                            double l;
                            if(c == '*'){
                                r = vals.pop();
                                l = vals.pop();
                                vals.push(l*r);
                            }else if(c == '/'){
                                r = vals.pop();
                                l = vals.pop();
                                vals.push(l/r);
                            }else if(c == '^'){
                                r = vals.pop();
                                l = vals.pop();
                                vals.push(pow(l,r));
                            }else if(c == 'q'){
                                r = vals.pop();
                                vals.push(sqrt(r));
                            } else if (c == 's') {
                                r = vals.pop();
                                vals.push(sin(r));
                            }else if(c == 'c'){
                                r = vals.pop();
                                vals.push(cos(r));
                            }else if(c == 't'){
                                r = vals.pop();
                                vals.push(tan(r));
                            }else if(c == 'e'){
                                r = vals.pop();
                                vals.push(exp(r));
                            }
                            c = ops.pop();
                        }
                        ops.push(c);
                        ops.push(ch[i]);
                        i++;
                        break;
                    case '^':
                        ops.push('^');
                        i ++;
                        break;
                }
                continue;
            }

遇到左括号直接入栈

else if(ch[i] == '('){
                ops.push(ch[i]);
                i ++;
                continue;
            }

遇到右括号，拼命弹出运算符和操作数，不停地算直到栈中遇到’#’（结束标志）或左括号

else if(ch[i] == ')' || ch[i] == '\0'){
                char c = ops.pop();
                while(c != '(' && c != '#'){
                    double r;
                    double l;
                    if(c == '+'){
                        r = vals.pop();
                        l = vals.pop();
                        vals.push(l + r);
                    }else if(c == '-'){
                        r = vals.pop();
                        l = vals.pop();
                        vals.push(l - r);
                    }else if(c == '*'){
                        r = vals.pop();
                        l = vals.pop();
                        vals.push(l*r);
                    }else if(c == '/'){
                        r = vals.pop();
                        l = vals.pop();
                        vals.push(l/r);
                    }else if(c == '^'){
                        r = vals.pop();
                        l = vals.pop();
                        vals.push(pow(l,r));
                    }else if(c == 'q'){
                        r = vals.pop();
                        vals.push(sqrt(r));
                    } else if (c == 's') {
                        r = vals.pop();
                        vals.push(sin(r));
                    }else if(c == 'c'){
                        r = vals.pop();
                        vals.push(cos(r));
                    }else if(c == 't'){
                        r = vals.pop();
                        vals.push(tan(r));
                    }else if(c == 'e'){
                        r = vals.pop();
                        vals.push(exp(r));
                    }

                    c = ops.pop();
                }
                i++;
                continue;

完整代码：

package Homework;

import java.util.Scanner;
import java.util.Stack;

import static java.lang.Math.*;

public class calculator2 {
    private static Stack<Double> vals = new Stack<Double>();
    private static Stack<Character> ops = new Stack<Character>();
    private static void calculate(String str){
        char[] ch = (str+"\0").toCharArray();
        ops.push('#');
        int i = 0;
        while(i < ch.length) {
            boolean isNegative = false;
            if(i + 4 <= ch.length){
                String str1 = new String(ch,i,3);
                String str2 = new String(ch,i,4);
                if(str1.equals("sin")) {
                    ops.push(ch[i]);//s表示sin
                    i+=3;
                }else if(str1.equals("cos")){
                    ops.push(ch[i]);//c表示cos
                    i+=3;
                }else if(str1.equals("tan") || str1.equals("tgn")){
                    ops.push(ch[i]);//t表示tan函数
                    i+=3;
                }else if(str1.equals("exp")){
                    ops.push(ch[i]);//e表示指数函数
                    i+=3;
                }else if(str2.equals("sqrt")){
                    ops.push('q');//q表示开方
                    i +=4;
                }
            }
            if(ch[i] == '-' && (vals.empty() || ops.lastElement() == '(')){
                isNegative = true;
                i ++;
            }
            if ((ch[i] >= '0' && ch[i] <= '9') || ch[i] == '.') {
                double val = 0;
                double temp = 1;
                boolean byPoint = false;
                while ((ch[i] >= '0' && ch[i] <= '9') || ch[i] == '.') {
                    if (ch[i] == '.') {
                        i++;
                        byPoint = true;
                        temp = 10;
                        continue;
                    }
                    if (byPoint) {
                        int x = (int) ch[i] - 48;
                        val += ((double) x) / temp;
                        temp = temp * 10;
                        i++;

                    } else {
                        int x = (int) ch[i] - 48;
                        val = val*10 + x;
                        i++;
                    }
                }
                if(isNegative) val = -1*val;
                vals.push(val);
                continue;
            }else if(ch[i] == '+' || ch[i] == '-' || ch[i] == '*'|| ch[i] == '/'||ch[i] == '^'){
                char t = ch[i];
                char c;
                switch (t){
                    case '+':
                    case '-':
                        c = ops.pop();
                       while (c != '(' && c != '#'){
                           double r;
                           double l;
                           if(c == '+'){
                               r = vals.pop();
                               l = vals.pop();
                               vals.push(l + r);
                           }else if(c == '-'){
                               r = vals.pop();
                               l = vals.pop();
                               vals.push(l - r);
                           }else if(c == '*'){
                               r = vals.pop();
                               l = vals.pop();
                               vals.push(l*r);
                           }else if(c == '/'){
                               r = vals.pop();
                               l = vals.pop();
                               vals.push(l/r);
                           }else if(c == '^'){
                               r = vals.pop();
                               l = vals.pop();
                               vals.push(pow(l,r));
                           }else if(c == 'q'){
                               r = vals.pop();
                               vals.push(sqrt(r));
                           } else if (c == 's') {
                               r = vals.pop();
                               vals.push(sin(r));
                           }else if(c == 'c'){
                               r = vals.pop();
                               vals.push(cos(r));
                           }else if(c == 't'){
                               r = vals.pop();
                               vals.push(tan(r));
                           }else if(c == 'e'){
                               r = vals.pop();
                               vals.push(exp(r));
                           }
                           c = ops.pop();


                       }
                       ops.push(c);
                       ops.push(ch[i]);
                       i++;
                       break;
                    case '*':
                    case '/':
                        c = ops.pop();
                        while (c != '(' && c != '#' && c != '+' && c != '-'){
                            double r;
                            double l;
                            if(c == '*'){
                                r = vals.pop();
                                l = vals.pop();
                                vals.push(l*r);
                            }else if(c == '/'){
                                r = vals.pop();
                                l = vals.pop();
                                vals.push(l/r);
                            }else if(c == '^'){
                                r = vals.pop();
                                l = vals.pop();
                                vals.push(pow(l,r));
                            }else if(c == 'q'){
                                r = vals.pop();
                                vals.push(sqrt(r));
                            } else if (c == 's') {
                                r = vals.pop();
                                vals.push(sin(r));
                            }else if(c == 'c'){
                                r = vals.pop();
                                vals.push(cos(r));
                            }else if(c == 't'){
                                r = vals.pop();
                                vals.push(tan(r));
                            }else if(c == 'e'){
                                r = vals.pop();
                                vals.push(exp(r));
                            }
                            c = ops.pop();
                        }
                        ops.push(c);
                        ops.push(ch[i]);
                        i++;
                        break;
                    case '^':
                        ops.push('^');
                        i ++;
                        break;
                }
                continue;
            }else if(ch[i] == '('){
                ops.push(ch[i]);
                i ++;
                continue;
            }else if(ch[i] == ')' || ch[i] == '\0'){
                char c = ops.pop();
                while(c != '(' && c != '#'){
                    double r;
                    double l;
                    if(c == '+'){
                        r = vals.pop();
                        l = vals.pop();
                        vals.push(l + r);
                    }else if(c == '-'){
                        r = vals.pop();
                        l = vals.pop();
                        vals.push(l - r);
                    }else if(c == '*'){
                        r = vals.pop();
                        l = vals.pop();
                        vals.push(l*r);
                    }else if(c == '/'){
                        r = vals.pop();
                        l = vals.pop();
                        vals.push(l/r);
                    }else if(c == '^'){
                        r = vals.pop();
                        l = vals.pop();
                        vals.push(pow(l,r));
                    }else if(c == 'q'){
                        r = vals.pop();
                        vals.push(sqrt(r));
                    } else if (c == 's') {
                        r = vals.pop();
                        vals.push(sin(r));
                    }else if(c == 'c'){
                        r = vals.pop();
                        vals.push(cos(r));
                    }else if(c == 't'){
                        r = vals.pop();
                        vals.push(tan(r));
                    }else if(c == 'e'){
                        r = vals.pop();
                        vals.push(exp(r));
                    }

                    c = ops.pop();
                }
                i++;
                continue;
            }else{
                System.out.println("输入异常！");
                break;
            }
        }
        System.out.println(vals.pop());

    }

    public static void main(String[] args) {
        while (true){
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入算数表达式：");
            String str = scanner.next();
            if(str.equals("#")){
                break;
            }

            try{
                calculate(str);
            }catch (Exception e){
                System.out.println("输入异常！");
            }
        }

    }
}

运行示范：

请输入算数表达式：
sin3.14
0.0015926529164868282
请输入算数表达式：
exp(1)*2+(-3)
2.43656365691809
请输入算数表达式：
#

Process finished with exit code 0
Tsoyim
关注
Java实现表达式计算求值
南 墙
07-21 2万+
问题描述 　　输入一个只包含加减乖除和括号的合法表达式，求表达式的值。其中除表示整除。 输入格式 　　输入一行，包含一个表达式。 输出格式 　　输出这个表达式的值。 样例输入 1-2+3*(4-5) 样例输出 -4 数据规模和约定 　　表达式长度不超过100，表达式运算合法且运算过程都在int内进行。 package com.liuzhen.systemExe; import java.uti...
java 求值算法_java实现任意四则运算表达式求值算法
weixin_36186183的博客
02-13 525
本文实例讲述了java实现任意四则运算表达式求值算法。分享给大家供大家参考。具体分析如下：该程序用于计算任意四则运算表达式。如 4 * ( 10 + 2 ) + 1 的结果应该为 49。算法说明：1. 首先定义运算符优先级。我们用一个Map>来保存优先级表。这样我们就可以通过下面的方式来计算两个运算符的优先级了：/*** 查表得到op1和op2的优先级* @param op1 运算符1* @...
java 通过字符串进行计算结果
最新发布
weixin_41410480的博客
07-13 58
如何通过字符串进行计算结果 1. 流程表格 步骤 操作 代码示例 1 输入字符串表达式 input = “1+2*3” 2 解析表达式 tokens = input.split(“[\+\-\*\/]”) 3 计算结果 result = calculate(tokens) 2. 代码实现 解析表...
表达式求值计算(java实现)
11-25
对用+、-、*、/、(、）连接起来的算术表达式求值， 可以智能识别和过滤表达式。
java 计算表达式的值_Java集合框架练习-计算表达式的值
weixin_39604189的博客
02-15 343
最近在看《算法》这本书，正好看到一个计算表达式的问题，于是就打算写一下，也正好熟悉一下Java集合框架的使用，大致测试了一下，没啥问题。import java.util.*;/*** 用来计算表达式* for example: 1+2*3*(4+3*1)-3*1+2+3/1;* (1+2*2-2*1*3*(1-1))*(1-2+3*(4+0));* 注意点：* 2.输入的表达书不能还有空格,括号必...
java计算表达式的值
tyut_fantao的专栏
09-17 1188
package sweexamination.level1; import java.util.ArrayList; import java.util.List; import java.util.Stack;  /**  *  转为后缀表达式：  *  操作数直接放入结果  *  当前操作符与栈中的操作符比较：  *  栈空：进  *  当前高：进  *  当前低：将栈顶
java表达式计算支持自定义运算
07-03
Java表达式计算支持自定义运算是一项重要的编程功能，它允许开发者根据特定需求扩展语言的运算符集合，并定义这些运算符的行为。在Java中，我们可以通过创建自己的类和接口来实现这个功能，使得程序能处理更复杂的...
Java数学表达式计算(Expression Evaluator)
08-04
总结来说，"Java数学表达式计算"涉及到如何在Java环境中解析和评估复杂的数学表达式。这可以通过使用Java内置的方法、第三方库如Apache Commons Math，或是自定义解析器实现。通过分析提供的`ExprEvalSample`代码，...
Java实现计算字符串表达式
03-17
- **性能优化**：对于大量表达式计算，优化解析和求值过程至关重要，例如使用缓存来避免重复解析相同的表达式。 - **安全**：避免SQL注入等安全风险，确保输入表达式只包含预期的运算符和操作数，防止恶意用户执行...
java数学表达式计算程序设计报告
11-12
在这个项目中，Java 被用来编写数学表达式计算程序，展示了其在软件开发中的灵活性。 2. 知识点：课程设计 该项目作为课程设计的一部分，旨在让学生应用所学的 Java 语言知识，通过实践提高编程技能和问题解决能力...
java字符串数学表达式（含括号）计算值
10-17
代码均为自己设计所写，分享一下。 字符串数学表达式（含括号）计算值 如： "31+3*3-20/2*5+40/8+4*5" ((2*(19-13*(1+2)/39)/6+4)-5)/5+((2+3)*2-5)
计算表达式的值-牛客网-编程入门(Java版)
一个有故事的程序员
03-26 360
计算表达式的值 题目描述： 请计算表达式“(-8+22)×a-10+c÷2”，其中，a = 40，c = 212。 输入描述: 无。 输出描述: (-8+22)×a-10+c÷2计算之后的结果，为一个整数。 代码实现： public class Main { public static void main(String[] args) { System.out.prin...
[044] 使用List和Stack实现综合计算器（后缀--逆波兰表达式）
yhxxhy978的博客
09-21 365
1、后缀表达式 中缀表达式如(3+4)*5-6是我们人类在书写数学表达式时最长使用的一种书写方式，但对于计算机来说，后缀表达式（又称为逆波兰表达式）更利于计算。 中缀表达式： (3+4)*5-6 -> 后缀表达式（逆波兰表达式）：3 4 + 5 * 6 - 中缀表达式：4*5-8+60+8/2 -> 后缀表达式（逆波兰表达式）：4 5 * 8 - 60 + 8 2 / + 后缀计算器的设计步骤如下： 将中缀表达式String转为中缀表达式List； 将中缀表达式List转为后缀表达式L
java表达式求值
weixin_43952736的博客
11-15 1018
安装Pyinstaller 表达式求值 实验11：整数算术表达式分析程序 题目类别: B作业 关键字: 类、对象、封装、类之间的关系、字符串 内容要求: 编写一个Java应用程序。 要求实现功能如下： (1) 从键盘输入一个表示整数四则运算的字符串，例如：32+5*2-40/3 四则运算符号： +代表整数加法、-代表整数减法、*代表整数乘法、/代表整数除法（结果为整数） 运算数全部为正...
表达式求值(java)
weixin_34274029的博客
10-14 206
今天去面试，考了这个，短时间没想出来。。。 太笨了！ 后来想用栈和递归做 但是看了网上才知道，可以将中缀表达式转为后缀表达式，就极其方便了。 import java.util.Scanner; import java.util.Stack; public class ExpressionCalc { private Stack<Character>...
Java实现计算表达式的值
Mr_Liuzhongbin的博客
12-12 4356
需求 已知一个只含有()、+ 、-、*、\这五种操作符，数字只是整数，并且空格隔开的表达式字符串，求表达式的值。 例如： ( 3 + 4 ) * 5 - 6 结果为29 解题思路 给定表达式为中缀表达式，将其转为后缀表达式（逆波兰表达式）然后使用逆波兰表达式求解值。 逆波兰表达式求解值得思路： 遍历表达式，遇到数值则入栈，遇到计算符则从栈中弹出两个元素然后将计算结果压入栈中。做减和除法运算的时候...
Java实现表达式求值
weixin_44329588的博客
05-22 1760
代码置于文章末 本文代码未使用栈 问题描述 输入一个表达式，表达式可以包括‘+’，‘-’，‘*’，‘/’，‘%’运算，可以出现整数及小数，可以出现“()”，但要求输入格式合法。 总体思路 当输入的表达式（下称s）中存在“()”时，对“()”内的表达式进行运算，并在s中将该“()”及其之中的表达式替换为运算结果； 直至s中无“()”，对s进行运算，输出结果。 运算思路 现在我们只需要考虑如何计算出一个没有“()”的表达式即可。 首先，明确：‘*’，‘/’，‘%’的运算优先级相同，且高于‘+’，‘-’，而‘+’
java实现表达式求值
ybc77107的博客
04-21 358
[例子和习题出自数据结构(严蔚敏版), 本人使用Java进行实现.  转载请注明作者和出处,  如有谬误, 欢迎在评论中指正. ] 对整数表达式求值. 表达式中可能包含+-*/四则运算, 以及括号, 比如:4 + 2 * 3 - 10 / 5, (1+2) * (4 + 5) - (9 / 7)等. 思路: 将括号之间的内容当做子表达式求值, 得出子表达式的结果后就可以去掉括号了. 使用...
求表达式的值java_Java表达式求值
weixin_36317943的博客
02-24 119
importjava.math.BigInteger;import java.util.*;public classMain{public static voidmain(String[] args){Scanner scan= newScanner(System.in);while(scan.hasNext()){String str1=scan.next();Stack num = new S...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值