注册 登录
编程论坛 → JAVA论坛

纯小白求助......这个java算法应该怎么写！！！！

java小白兔 发布于 2018-11-12 12:27， 2431 次点击

只有本站会员才能查看附件，请 登录

只有本站会员才能查看附件，请 登录


[此贴子已经被作者于2018-11-21 06:43编辑过]

8 回复
#2
幻紫灵心2018-11-12 13:22
用栈可以写数学表达式
#3
java小白兔2018-11-12 17:21
回复 2楼 幻紫灵心
用栈怎么写呢？原理我懂，就是看表达式的优先级和数字的进栈出栈，具体要怎么写呢？
#4
java小白兔2018-11-13 07:54
回复 3楼 java小白兔
import
import
import java.util.ArrayList;
public class Main{
    public static void main(String[] args)throws Exception{
        //1读取输入的表达式
        InputStreamReader irs = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(irs);
        String express = br.readLine();
        
        //2将表达式中的数值分割出来
        String[] valueS = express.split("\\+|-|\\*|/");
        ArrayList<Integer> valueArrayList = new ArrayList<Integer>();
        ArrayList<Integer> valueArrayList1 = new ArrayList<Integer>();
        for(String s: valueS){
            int n = Integer.parseInt(s);
            valueArrayList.add(n);
        }
        //3将表达式中的操作符分割出来
        ArrayList<Character> opsArrayList = new ArrayList<Character>();
        ArrayList<Character> opsArrayList1 = new ArrayList<Character>();
        for(int i =0;i<express.length();i++){
            char ops = express.charAt(i);
            if(ops == '+' || ops == '-' || ops == '*' || ops == '/'){
                opsArrayList.add(ops);
            }
        }
        
        //4循环表达式，将表达式中所以的*或/的式子进行计算
        int index = 0;
   flag:while(index < opsArrayList.size()){//这个while的条件可以一直为true；
            //5找到第一个*或/的位置startIndex。如果没有则跳出循环
            char c = opsArrayList.get(index);
            while( c != '*' && c != '/'){
                index++;
               
                if(index >= opsArrayList.size()){
                    break flag;//break flag 可以跳出两次层循环的。就是跳出flag的位置。表明该表达式中没有*或/。
                }
                c = opsArrayList.get(index);
            }
            int startIndex = index;
            
            //6找到连续几个*或/的最后一个位置endIndex；
            c = opsArrayList.get(startIndex);
            while( c == '*' || c == '/'){
                index++;
                if(index >= opsArrayList.size()){
                    break;//跳出本while循环，表明找到最后一个操作符，进行7的子表达式计算
                }
                c = opsArrayList.get(index);
            }
            int endIndex = index-1;
            
            //7对这个*或/的子表达式进行计算，得出结果sum
            int sum = valueArrayList.get(startIndex);
            for(int i = startIndex;i<= endIndex;i++){
                char cops = opsArrayList.get(i);
                if(cops == '*'){
                    sum *= valueArrayList.get(i+1);
                }else if(cops == '/'){
                    sum = sum / valueArrayList.get(i+1);
                }
            }
            //8删除刚计算的子表达式中的操作数以及操作符。并把结果sum放入第一个操作数的位置startIndex
            for(int i = 1;i<= (endIndex-startIndex)+1;i++){
                opsArrayList.remove(startIndex);
                valueArrayList.remove(startIndex);
            }
            valueArrayList.remove(startIndex);
            valueArrayList.add(startIndex,sum);
        }
        //9将得到的只包含+或-表达式进行计算
        int result = valueArrayList.get(0);
        for(int i=0;i<opsArrayList.size();i++){
            char cops = opsArrayList.get(i);
            if(cops == '+'){
                result += valueArrayList.get(i+1);
            }else if(cops == '-'){
                result -= valueArrayList.get(i+1);
            }
        }
        System.out.println(result);
    }
}
#5
java小白兔2018-11-13 07:55
回复 2楼 幻紫灵心
你能帮我看下我写的这个代码嘛，有点错误
import
import
import java.util.ArrayList;
public class Main{
    public static void main(String[] args)throws Exception{
        //1读取输入的表达式
        InputStreamReader irs = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(irs);
        String express = br.readLine();
        
        //2将表达式中的数值分割出来
        String[] valueS = express.split("\\+|-|\\*|/");
        ArrayList<Integer> valueArrayList = new ArrayList<Integer>();
        ArrayList<Integer> valueArrayList1 = new ArrayList<Integer>();
        for(String s: valueS){
            int n = Integer.parseInt(s);
            valueArrayList.add(n);
        }
        //3将表达式中的操作符分割出来
        ArrayList<Character> opsArrayList = new ArrayList<Character>();
        ArrayList<Character> opsArrayList1 = new ArrayList<Character>();
        for(int i =0;i<express.length();i++){
            char ops = express.charAt(i);
            if(ops == '+' || ops == '-' || ops == '*' || ops == '/'){
                opsArrayList.add(ops);
            }
        }
        
        //4循环表达式，将表达式中所以的*或/的式子进行计算
        int index = 0;
   flag:while(index < opsArrayList.size()){//这个while的条件可以一直为true；
            //5找到第一个*或/的位置startIndex。如果没有则跳出循环
            char c = opsArrayList.get(index);
            while( c != '*' && c != '/'){
                index++;
               
                if(index >= opsArrayList.size()){
                    break flag;//break flag 可以跳出两次层循环的。就是跳出flag的位置。表明该表达式中没有*或/。
                }
                c = opsArrayList.get(index);
            }
            int startIndex = index;
            
            //6找到连续几个*或/的最后一个位置endIndex；
            c = opsArrayList.get(startIndex);
            while( c == '*' || c == '/'){
                index++;
                if(index >= opsArrayList.size()){
                    break;//跳出本while循环，表明找到最后一个操作符，进行7的子表达式计算
                }
                c = opsArrayList.get(index);
            }
            int endIndex = index-1;
            
            //7对这个*或/的子表达式进行计算，得出结果sum
            int sum = valueArrayList.get(startIndex);
            for(int i = startIndex;i<= endIndex;i++){
                char cops = opsArrayList.get(i);
                if(cops == '*'){
                    sum *= valueArrayList.get(i+1);
                }else if(cops == '/'){
                    sum = sum / valueArrayList.get(i+1);
                }
            }
            //8删除刚计算的子表达式中的操作数以及操作符。并把结果sum放入第一个操作数的位置startIndex
            for(int i = 1;i<= (endIndex-startIndex)+1;i++){
                opsArrayList.remove(startIndex);
                valueArrayList.remove(startIndex);
            }
            valueArrayList.remove(startIndex);
            valueArrayList.add(startIndex,sum);
        }
        //9将得到的只包含+或-表达式进行计算
        int result = valueArrayList.get(0);
        for(int i=0;i<opsArrayList.size();i++){
            char cops = opsArrayList.get(i);
            if(cops == '+'){
                result += valueArrayList.get(i+1);
            }else if(cops == '-'){
                result -= valueArrayList.get(i+1);
            }
        }
        System.out.println(result);
    }
}
#6
zc25468859762018-11-13 08:36
#7
幻紫灵心2018-11-13 14:03
看了下你的代码，感觉改起来有点难度...就自己写了一个
一般整数计算，刚开始没看到有超大数...
程序代码：

import java.util.*;
class Main {
    private static String[] toExpressionArray(String originalExpression) {//将原始字符串表达式分割成字符串数组，成员可能有空值
        StringBuffer buf = new StringBuffer();
        for(int i=0;i<originalExpression.length();i++) {
            if(Character.isDigit(originalExpression.charAt(i))) {
                buf.append(originalExpression.charAt(i));
            } else {
                buf.append(' ');
                buf.append(originalExpression.charAt(i));
                buf.append(' ');
            }
        }
        return buf.toString().split(" ");
    }
    private static int intOP(char op) {//返回符号整数优先级
        switch(op) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        case '^':
            return 3;
        default:
            System.out.print("operational character ERROR");
            System.exit(0);
            return 0;
        }
    }
    private static int calc(char op,int num1,int num2) {//计算
        switch(op) {
        case '+': return num2 + num1;
        case '-': return num2 - num1;
        case '*': return num2 * num1;
        case '/':
            try {
                return num2 / num1;
            } catch(ArithmeticException e) {//除零
                System.out.print("ERROR");
                System.exit(0);
            }
        case '^': return (int)Math.pow(num2, num1);
        default:
            System.out.print("operational character ERROR");
            System.exit(0);
            return 0;
        }
    }
    public static void main(String[] args) {
        //读入值并分割
        Scanner scan = new Scanner(System.in);
        String expression = scan.nextLine();
        scan.close();
        String[] expressionArray = toExpressionArray(expression);
        
        Stack<Integer> ovs = new Stack<Integer>();//数字栈
        Stack<Character> optr = new Stack<Character>();//符号栈
        for(String str : expressionArray) {
            if(str.length()==0) continue;//空值忽略
            if(Character.isDigit(str.charAt(0))) {//数字直接入数字栈
                ovs.push(Integer.valueOf(str));
            } else {//符号处理
                char op = str.charAt(0);
                if(op=='(') {//左括号，直接入栈
                    optr.push(op);
                } else if(op==')') {//右括号，计算至左括号
                    while(optr.peek()!='(') {
                        ovs.push(calc(optr.pop(),ovs.pop(),ovs.pop()));
                    }
                    optr.pop();//弹出左括号
                } else {//非括号，计算符
                    while(!optr.empty() && optr.peek()!='(' && intOP(op)<=intOP(optr.peek())) {//当前运算符优先级小于符号栈顶优先级，且符号栈非空非括号
                        ovs.push(calc(optr.pop(),ovs.pop(),ovs.pop()));//计算
                    }
                    optr.push(op);//当前符号入栈
                }
            }
        }
        while(!optr.empty()) {//清空运算
            ovs.push(calc(optr.pop(),ovs.pop(),ovs.pop()));
        }
        System.out.print(ovs.pop());
    }
}


超大数字计算。你图上的样例输入都能通过，可能还会有bug，你测试一下吧。
程序代码：

import java.math.BigInteger;
import java.util.*;
class Main {
    private static String[] toExpressionArray(String originalExpression) {//将原始字符串表达式分割成字符串数组，成员可能有空值
        StringBuffer buf = new StringBuffer();
        for(int i=0;i<originalExpression.length();i++) {
            if(Character.isDigit(originalExpression.charAt(i))) {
                buf.append(originalExpression.charAt(i));
            } else {
                buf.append(' ');
                buf.append(originalExpression.charAt(i));
                buf.append(' ');
            }
        }
        return buf.toString().split(" ");
    }
    private static int intOP(char op) {//返回符号整数优先级
        switch(op) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        case '^':
            return 3;
        default:
            System.out.print("operational character ERROR");
            System.exit(0);
            return 0;
        }
    }
    private static BigInteger calc(char op,BigInteger num1,BigInteger num2) {//计算
        switch(op) {
        case '+': return num2.add(num1);
        case '-': return num2.subtract(num1);
        case '*': return num2.multiply(num1);
        case '/':
            try {
                return num2.divide(num1);//整除
            } catch(ArithmeticException e) {//除零
                System.out.print("ERROR");
                System.exit(0);
            }
        case '^': return num2.pow(num1.intValue());
        default:
            System.out.print("operational character ERROR calc");
            System.exit(0);
            return null;
        }
    }
    public static void main(String[] args) {
        //读入值并分割
        Scanner scan = new Scanner(System.in);
        String expression = scan.nextLine();
        scan.close();
        String[] expressionArray = toExpressionArray(expression);
        
        Stack<BigInteger> ovs = new Stack<BigInteger>();//数字栈
        Stack<Character> optr = new Stack<Character>();//符号栈
        for(String str : expressionArray) {
            if(str.length()==0) continue;//空值忽略
            if(Character.isDigit(str.charAt(0))) {//数字直接入数字栈
                ovs.push(new BigInteger(str));
            } else {//符号处理
                char op = str.charAt(0);
                if(op=='(') {//左括号，直接入栈
                    optr.push(op);
                } else if(op==')') {//右括号，计算至左括号
                    while(optr.peek()!='(') {
                        ovs.push(calc(optr.pop(),ovs.pop(),ovs.pop()));
                    }
                    optr.pop();//弹出左括号
                } else {//非括号，计算符
                    while(!optr.empty() && optr.peek()!='(' && intOP(op)<=intOP(optr.peek())) {//当前运算符优先级小于符号栈顶优先级，且符号栈非空非括号
                        ovs.push(calc(optr.pop(),ovs.pop(),ovs.pop()));//计算
                    }
                    optr.push(op);//当前符号入栈
                }
            }
        }
        while(!optr.empty()) {//清空运算
            ovs.push(calc(optr.pop(),ovs.pop(),ovs.pop()));
        }
        System.out.print(ovs.pop());
    }
}
#8
java小白兔2018-11-13 16:15
回复 6楼 zc2546885976
多谢大佬
#9
java小白兔2018-11-13 20:00
回复 7楼 幻紫灵心
多谢，万分感谢
1
©2025, BC-CN.NET
电脑版