华为机试-四则运算/表达式求值

问题描述

输入一个表达式（用字符串表示），求这个表达式的值。
保证字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。且表达式一定合法

输入描述:
输入一个算术表达式

输出描述:
得到计算结果

示例

示例1

输入
3+2*{1+2*[-4/(8-6)+7]}

输出
25

解决思路

分析

问题的关键在于如何运用栈实现整个计算过程。

方法

1. 这里我直接采用了逆波兰表达式的思路解决

逆波兰表达式：
也即后缀表达式，指的是不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则）。（摘自百度），既然没了运算符的优先规则，那么计算机解析起来自然容易的多。
对于我们常见的表达式，称为中缀表达式，每个中缀表达式都有对应的后缀表达式。如：
中缀表达式：-2*(1+6/3)+4
后缀表达式：-2 1 6 3 / + * 4 +

通过以上方法，我们可以使用如下方法

使用两个栈，一个数字栈，一个符号栈
从左往右遍历表达式字符串

1. 遇到数字，直接压入数字栈
2. 遇到符号
   2.1 遇到左括号，直接入符号栈
   2.2 遇到右括号，”符号栈弹栈取栈顶符号b，数字栈弹栈取栈顶数字a1，数字栈弹栈取栈顶数字a2，计算a2 b a1 ,将结果压入数字栈”，重复引号步骤至取栈顶为左括号，将左括号弹出
   2.3 遇到运算符，
   1）若该运算符的优先级大于栈顶元素的优先级，直接入符号栈。
   2）若小于，”符号栈弹栈取栈顶符号b，数字栈弹栈取栈顶数字a1，数字栈弹栈取栈顶数字a2，计算a2 b a1 ,将结果压入数字栈”，重复引号步骤至该运算符的优先级大于符号栈顶元素的优先级，然后将该符号入符号栈遍历结束后，”
3. 符号栈弹栈取栈顶符号b，数字栈弹栈取栈顶数字a1，数字栈弹栈取栈顶数字a2，计算a2 b a1 ,将结果压入数字栈”，重复引号步骤至符号栈无符号（或数字栈只有一个元素），则数字栈的元素为运算结果

代码实现

import java.util.*;
import java.util.regex.*;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        //输入参数
        String a = in.next();
        
        System.out.println(getResult(a));
    }
    
     public static int getResult(String input) {
        Pattern pattern = Pattern.compile("((?<![\\d)])-?\\d+(\\.\\d+)?|[+\\-*/()])");// 匹配数字和运算符
        input = input.replaceAll("[{\\[]", "(").replaceAll("[}\\]]", ")");//替换其他类型的括号
        Matcher matcher = pattern.matcher(input);
        Stack<String> number = new Stack<>(); // 操作数栈
        Stack<String> operator = new Stack<>(); // 操作数栈
        operator.push("null"); // 操作数栈头部放入
        while (matcher.find()) {
            String temp = matcher.group();
            if (temp.matches("[()]")) { // 括号
                if ("(".equals(temp)) { // 左括号入站
                    operator.push("(");
                } else {
                    String b = null;
                    while (!(b = operator.pop()).equals("(")) { // 右括号，弹出，直到遇到左括号，将新的计算结果入栈
                        number.push(calculate(b, number.pop(), number.pop()));
                    }
                }
            } else if (temp.matches("[+\\-*/]")) { // 运算符
                // 判断当前符号跟栈顶符号的优先级，如果优先级大，直接入栈
                if (getPriority(temp) > getPriority(operator.peek())) {
                    operator.push(temp);
                } else {
                    // 如果优先级小，出栈计算，直到遇到优先级大的，重新入栈
                    while (getPriority(temp) <= getPriority(operator.peek())) {
                        number.push(calculate(operator.pop(), number.pop(), number.pop()));
                    }
                    operator.push(temp);
                }
            } else {
                // 数字直接入站
                number.push(temp);
            }
        }
        // 遍历结束后，依次弹出操作数，出栈计算，后入站
        while (number.size() > 1) {
            number.push(calculate(operator.pop(), number.pop(), number.pop()));
        }
        return (int) Double.parseDouble(number.pop());
    }

    // 返回设定符号的优先级
    private static int getPriority(String b) {
        switch (b) {
            case "+":
            case "-":
                return 1;
            case "*":
            case "/":
                return 2;
        }
        return 0;
    }

    private static String calculate(String b, String a1, String a2) {
        double result = 0;
        double d1 = Double.parseDouble(a2);
        double d2 = Double.parseDouble(a1);
        switch (b) {
            case "+":
                result = d1 + d2;
                break;
            case "-":
                result = d1 - d2;
                break;
            case "*":
                result = d1 * d2;
                break;
            case "/":
                result = d1 / d2;
                break;
        }
        return result + "";
    }
}

小伙伴如果想测试的话，可以直接到牛客网这个链接做测试

华为机试-牛客网