算法训练 表达式计算 Java

资源限制

时间限制:1.0s   内存限制:256.0MB

问题描述

  输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除。

输入格式

  输入一行,包含一个表达式。

输出格式

  输出这个表达式的值。

样例输入

1-2+3*(4-5)

样例输出

-4

数据规模和约定

  表达式长度不超过100,表达式运算合法且运算过程都在int内进行。

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

public class Main {

   
    static Stack<Integer> integers=new Stack<>();
    static Stack<Character> characters=new Stack<>();
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String str=in.nextLine();

        characters.push('#');
        char[] chs=str.toCharArray();
        int num=0;

        //数字
        for(int i=0;i<str.length();i++){
            if(chs[i]>='0'&&chs[i]<='9'){
                num=chs[i]-'0';
                for (i = i + 1; i < str.length(); i++) {
                    if ('0' <= chs[i] && chs[i] <= '9') {
                        num = num * 10 + (chs[i] - '0');
                    } else {
                        i--;
                        break;
                    }
                }
                integers.push(num);
                continue;
            }
           
            if(chs[i]=='+'||chs[i]=='-'||chs[i]=='*'||chs[i]=='/'){
                while (opCompare(characters.peek(),chs[i])&&integers.size()>1){
                    calc();
                }
                characters.push(chs[i]);
                continue;
            }

            if(chs[i]=='('){
                characters.push(chs[i]);
                continue;
            }

            if(chs[i]==')'){
                while (characters.peek()!='('&&integers.size()>1){
                    calc();
                }
                characters.pop();
            }
        }
        while (integers.size()>1){
            calc();
        }
        System.out.println(integers.get(0));
    }

    
    public static boolean opCompare(char op1,char op2){
        if(op1=='*'||op1=='/'){
            return true;
        }
        if(op2=='*'||op2=='/'||op1=='('){
            return false;
        }
        return true;
    }

    public static void calc(){
        char op=characters.pop();
        int num2=integers.pop();
        int num1=integers.pop();

        switch (op){
            case '+':
                integers.push(num1+num2);
                break;
            case '-':
                integers.push(num1-num2);
                break;
            case '*':
                integers.push(num1*num2);
                break;
            case '/':
                integers.push(num1/num2);
                break;
            default:break;
        }
    }

}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,为了完成这个任务,我们需要以下几个步骤: 1. 定义一个栈结构,用于存储运算符和操作数。 2. 读入一个中缀表达式字符串。 3. 将中缀表达式字符串转换为后缀表达式字符串。 4. 计算后缀表达式字符串的值。 以下是具体的代码实现: 1. 定义栈结构 我们可以使用 Java 的 Stack 类来实现栈结构。定义如下: ``` import java.util.Stack; public class ExpressionCalculator { private Stack<Character> operatorStack; private Stack<Double> operandStack; public ExpressionCalculator() { operatorStack = new Stack<Character>(); operandStack = new Stack<Double>(); } //... } ``` 在这个类中,我们定义了两个栈:`operatorStack` 用于存储运算符,`operandStack` 用于存储操作数。 2. 读入中缀表达式字符串 我们可以使用 Java 的 Scanner 类来读入中缀表达式字符串。定义如下: ``` import java.util.Scanner; public class ExpressionCalculator { //... public void inputExpression() { Scanner scanner = new Scanner(System.in); System.out.print("请输入中缀表达式:"); String expression = scanner.nextLine(); //... } } ``` 在这个方法中,我们通过 `Scanner.nextLine()` 方法读入用户输入的中缀表达式字符串。 3. 将中缀表达式字符串转换为后缀表达式字符串 我们可以使用栈结构来实现中缀表达式转后缀表达式算法。具体实现如下: ``` public String infixToPostfix(String infix) { StringBuilder postfix = new StringBuilder(); for (int i = 0; i < infix.length(); i++) { char ch = infix.charAt(i); if (Character.isDigit(ch)) { // 如果是数字,直接输出到后缀表达式字符串中 postfix.append(ch); } else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') { // 如果是运算符 while (!operatorStack.empty() && priority(operatorStack.peek()) >= priority(ch)) { postfix.append(operatorStack.pop()); } operatorStack.push(ch); } else if (ch == '(') { // 如果是左括号 operatorStack.push(ch); } else if (ch == ')') { // 如果是右括号 while (operatorStack.peek() != '(') { postfix.append(operatorStack.pop()); } operatorStack.pop(); // 弹出左括号 } } // 将剩余的运算符输出到后缀表达式字符串中 while (!operatorStack.empty()) { postfix.append(operatorStack.pop()); } return postfix.toString(); } private int priority(char ch) { switch (ch) { case '+': case '-': return 1; case '*': case '/': return 2; default: return 0; } } ``` 在这个方法中,我们遍历中缀表达式字符串的每个字符。如果是数字,则直接输出到后缀表达式字符串中;如果是运算符,则将它和栈顶的运算符进行比较,如果栈顶的运算符优先级大于等于当前运算符,则弹出栈顶的运算符并输出到后缀表达式字符串中,直到栈顶的运算符优先级小于当前运算符或栈为空时,将当前运算符压入栈中;如果是左括号,则直接压入栈中;如果是右括号,则弹出栈中的运算符并输出到后缀表达式字符串中,直到遇到左括号为止。 4. 计算后缀表达式字符串的值 我们可以使用栈结构来实现后缀表达式计算算法。具体实现如下: ``` public double evaluate(String postfix) { for (int i = 0; i < postfix.length(); i++) { char ch = postfix.charAt(i); if (Character.isDigit(ch)) { // 如果是数字,压入操作数栈中 operandStack.push((double) (ch - '0')); } else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') { // 如果是运算符,弹出操作数栈中的两个操作数进行计算,将结果压入操作数栈中 double operand2 = operandStack.pop(); double operand1 = operandStack.pop(); switch (ch) { case '+': operandStack.push(operand1 + operand2); break; case '-': operandStack.push(operand1 - operand2); break; case '*': operandStack.push(operand1 * operand2); break; case '/': operandStack.push(operand1 / operand2); break; } } } // 返回操作数栈中的唯一元素,即计算结果 return operandStack.pop(); } ``` 在这个方法中,我们遍历后缀表达式字符串的每个字符。如果是数字,则将它转换为 double 类型并压入操作数栈中;如果是运算符,则弹出操作数栈中的两个操作数进行计算,将结果压入操作数栈中。最终,操作数栈中只剩下一个元素,就是计算结果。 完整代码如下:

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值