逆波兰式java

❶ java如何计算比较复杂的数学计算，比如有括号同时有+-*/，顺序不一定，就是一个运算公式

可以用编译原理的思想来理解，主要用到数据结构里面的栈和队列。
利用栈的后进先出以及运算符号(+-*/(){} )优先级，对运算符号进行匹配。
分两个栈，一个是符号栈，一个是数字栈。
栈的每一次pop出一个字符，要进行校验，如果匹配（符合运算规则）则计算，并保存结果到数据栈。

❷ 字符串形式的表达式如何计算

不知道你用的是C 还是C++
不知道你有没有写过计算器的程序 如果写过的话就好办了
首先将得到的字符串存到一个字符串数组中 然后遍历数组 找出括号的位置 switch case语句懂的吧 然后将括号里的字符串提取出来再进行遍历 找出乘法除法的位置并且进行计算 算好以后再计算加减法再算好以后再算括号外的 同样的顺序 这样就可以进行计算了

❸ java数据结构对逆波兰式进行求值运算，并将结果进行输出

ACM队的mdd想做一个计算器，但是，他要做的不仅仅是一计算一个A+B的计算器，他想实现随便输入一个表达式都能求出它的值的计算器，现在请你帮助他来实现这个计算器吧。
比如输入：“1+2/4=”，程序就输出1.50（结果保留两位小数）

❹ java怎样计算一个String类型的数学表达式

只有自己实现一个方法了，先将这类表达式转换成逆波兰式表达式，再使用栈进行计算，实现起来是有一定难度的，特别是其中还夹杂着幂、乘、除、括号等有先后运算顺序的运算符。

❺ 输入一个字符串，包含数字和加(+)、减(-)、乘(*)、除(/)等四则运算符号，要求输出其计算结果

入一个字符串，包含数字和加(+)、减(-)、乘(*)、除(/)等四则运算符号，符串的四则运算。给出一个字符串，包含0~9的数字和+-*/()的运算符，-仅代表减号不代表负数。

举例如下：输入：1+2*(3-4)，输出：-1。思路：分析字符串的合法性， 模拟四则运算规则，按照先括号后乘除最后加减的顺序计算(逆波兰式)。

(5)逆波兰式java扩展阅读：

测试用例：

a.空串

b.一般输入， 1+2*(3-4)

c.多层括号嵌套， 1+2*((3-4)+8)

d.非法字符输入，9+A+8

e.非法计算符号，*-20+5

f.括号不匹配，1+2*(3-4)(

g.括号内为空，1+2*()*9

h.除零情况，1+2*6/(3-3)

❻ java后缀表达式实现表达式求值

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

public class 表达式计算 {
private static Stack<String> num = new Stack<String>();//存后缀表达式
private static Stack<String> sign = new Stack<String>();//存入符号
private static Stack<Integer> result = new Stack<Integer>();//放结果

public static void getGroup(String line){//讲字符串转换为后缀表达式
for(int i=0; i<line.length(); i++){
char c = line.charAt(i);
if((int)c>=48 && (int)c<=57){//当遇到数字的时候,判断是不是多位数，然后在push进num
int j = i+1;
while(j<line.length() && (line.charAt(j)>=48 && line.charAt(j)<=57)){
j++;
}
num.push(line.substring(i, j));
i = j-1;
}else if(c == '('){//遇到左括号直接存进num
sign.push(String.valueOf(c));
}else if(c == ')'){//遇到右括号从sign中pop栈顶元素push到num知道遇到'(',然后再pop掉'('
while(!sign.peek().equals("(")){
num.push(sign.pop());
}
sign.pop();
}else{
int n = 0;
if(!sign.empty()){//如果sign中没有元素，直接令n = 0
n = getNum(sign.peek().charAt(0));
}
int m = getNum(c);
if(m >= n){//如果当前元素的运算级别比栈顶元素运算级别要高，就直接push进sign
sign.push(String.valueOf(c));
}else{
while(m < n){//如果当前运算运算级别比sign栈顶元素运算级别要低，就将sign栈顶元素pop并且push进num，知道不符合条件
num.push(sign.pop());//输入例子2*3+6/3的时候，这里一直报错
if(!sign.empty()){
n = getNum(sign.peek().charAt(0));
}else{
n = 0;
}
}
sign.push(String.valueOf(c));
}
}
}
while(!sign.empty()){
num.push(sign.pop());
}
}

private static int getNum(char c){
int n = 0;
switch(c){
case '+':
case '-':
n = 1;
break;
case '*':
case '/':
n = 2;
break;
}
return n;
}

❼ java 设计算法，计算用后缀表示法表示的算术表达式的值。

你好！
后缀表达式也称逆波兰表达式，其优点就在于可以方便的用栈实现表达式的值的计算。和你说一下思路吧：
·从头读入表达式
·如果遇到数则将其压入栈
·如果遇到运算符，从栈中弹出栈顶连个数，实行相应运算，将结果压入栈中
·直到表达式尾，此时栈中应该只有一个元素，即运算结果
·Over
如果对你有帮助，望采纳。

❽ java整式计算，怎么实现类似这种效果的，不要中间那个"原式="

把普通的表达式表示成逆波兰式，然后用堆栈挨个读取，遇到符号按照符号的定义去取前边的俩个数字，计算完成将计算结果入栈，然后直到所有符号都运算完。你随便搜一下堆栈表达式求值。

❾ 用Java写的计算器的程序！不需要界面！

用java写的计算器的程序，主要是通过控制台输入，主要方法是使用scanner类来接收用户从键盘输入的一个算式，通过分解算式，存入两个字符串，判断中间的的符号，进行相应计算，如下代码：

System.out.println("-----------------------------------");
System.out.println("请输入一个算术表达式，如：45*23");
Scannerin=newScanner(System.in);//接收用户从键盘输入的字符
Stringstr=in.nextLine();
StringBufferbuffer=newStringBuffer();//保存左侧的数字
StringBufferbuffer1=newStringBuffer();//保存右侧的数字
chart='';//保存运算符
for(inti=0;i<str.length();i++){
if(str.charAt(i)=='+'||str.charAt(i)=='-'
||str.charAt(i)=='*'||str.charAt(i)=='/'){
t=str.charAt(i);//识别是什么运算符

for(intj=i+1;j<str.length();j++){
buffer1.append(str.charAt(j));
}
break;
}else{
buffer.append(str.charAt(i));
}
}
Stringc=buffer.toString();
Stringd=buffer1.toString();
doublea=Double.parseDouble(c);
doubleb=Double.parseDouble(d);
doublesum=0;
if(t=='+'){
sum=a+b;
}
if(t=='-'){
sum=a-b;
}
if(t=='*'){
sum=a*b;
}
if(t=='/'){
sum=a/b;
}
System.out.println("程序运算...");
System.out.println(c+t+d+"="+sum);
System.out.print("-----------------------------------");

运行结果如下：

❿ Java计算字符串中的数学表达式的值算法怎么写

代码网上很多，只说说算法吧
12+8/4-5+(3-4)

把这样的表达式拆成：(操作数)(操作符) 、
12+
8/
4-
5+(
3-
4)
(术语叫做逆波兰式)
默认的计算顺序是从左往右，记为left。另设从右往左，记为right
设计Element类，具有 操作数 operant, 操作符operator, 操作顺序 order三个属性
用两个先进后出的栈结构Stack<Element> a,b;
一开始所有的Element都在a中，逐个弹出计算合并值，
当遇到乘、除、括号时计算顺序改变成right，把当前结果放到b中暂存。
直到再次遇到加、减、)右括号时，意味计算顺序复位成left，先把b中的暂存结果全部合并后，再继续算a中的剩余数据
最后合并成一个结果值。