Java 字符串运算之模拟计算器问题

最新推荐文章于 2022-06-07 18:51:24 发布

原创最新推荐文章于 2022-06-07 18:51:24 发布 · 1k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #java #leetcode

Java字符串运算式

此笔记以Leetcode.282 和 Leetcode.227 为例子，解读一下计算器问题。代码来自公众号 宫水三叶的刷题日记 ，欢迎大家关注这个大神。或者直接去看她的解读三叶姐姐解读计算器问题。

一般的字符串运算式中有 + - * / 或者加上括号还有 % ^ ，这时候就需要考虑运算优先级，还有括号优先级。
先说运算优先级，加减乘除求余幂都有等级，索性就使用一个Map来存放优先级，key为运算符，value为优先级，例如：

//一般作为全局变量
    Map<Character, Integer> map = new HashMap<>(){{
        put('-', 1);
        put('+', 1);
        put('*', 2);
        put('/', 2);
        put('%', 2);
        put('^', 3);
    }};

这样子就方便判断运算符的优先级了。

处理这种问题一般使用双栈，一个用来压数字，一个用来压运算符。在做运算的时候一个一个对应着取出来。最先判断的是括号，在压入括号的时候就很重要。
如果碰到左括号" ( "，就直接压入运算符的栈。
如果是右括号 " ) "，就要让他找到最近的一个左括号，前提是运算符栈不是空的，然后就开始出栈运算直到碰到最近的左括号 " ( "，因为括号内运算优先嘛，计算的结果再压入数字的栈内。
接下来就是判断是运算符还是数字:

如果是数字，需要加入其全部的数字，比如123，就得加入所有数字，用一个循环连续取出，然后取出的第一位不断 ×10，就可以得到完整的数字，然后压栈。
如果是运算符，就需要知道是不是开头的运算符，比如说 ‘-1’ 这种数据，或者是加了括号的 ’ (- 1’ 这类，就在括号和符号之间加0。不是开头的话可以开始运算，这样减少后期时间，把能算的都先算了，前提是栈内运算符优先级比当前运算符优先级高（栈是先入后出嘛，所以是和之前的比）。然后再压栈。
至此基本思路就讲完了，这种问题有好多细节，括号问题，首字符问题，优先级问题，挺综合的，看代码吧，这是 Leetcode.227 的代码：

class Solution {
    // 使用 map 维护一个运算符优先级
    // 这里的优先级划分按照「数学」进行划分即可
    Map<Character, Integer> map = new HashMap<>(){{
        put('-', 1);
        put('+', 1);
        put('*', 2);
        put('/', 2);
        put('%', 2);
        put('^', 3);
    }};
    public int calculate(String s) {
        // 将所有的空格去掉
        s = s.replaceAll(" ", "");
        char[] cs = s.toCharArray();
        int n = s.length();
        // 存放所有的数字
        Deque<Integer> nums = new ArrayDeque<>();
        // 为了防止第一个数为负数，先往 nums 加个 0
        nums.addLast(0);
        // 存放所有「非数字以外」的操作
        Deque<Character> ops = new ArrayDeque<>();
        for (int i = 0; i < n; i++) {
            char c = cs[i];
            if (c == '(') {
                ops.addLast(c);
            } else if (c == ')') {
                // 计算到最近一个左括号为止
                while (!ops.isEmpty()) {
                    if (ops.peekLast() != '(') {
                        calc(nums, ops);
                    } else {
                        ops.pollLast();
                        break;
                    }
                }
            } else {
                if (isNumber(c)) {
                    int u = 0;
                    int j = i;
                    // 将从 i 位置开始后面的连续数字整体取出，加入 nums
                    while (j < n && isNumber(cs[j])) u = u * 10 + (cs[j++] - '0');
                    nums.addLast(u);
                    i = j - 1;
                } else {
                    if (i > 0 && (cs[i - 1] == '(' || cs[i - 1] == '+' || cs[i - 1] == '-')) {
                        nums.addLast(0);
                    }
                    // 有一个新操作要入栈时，先把栈内可以算的都算了 
                    // 只有满足「栈内运算符」比「当前运算符」优先级高/同等，才进行运算
                    while (!ops.isEmpty() && ops.peekLast() != '(') {
                        char prev = ops.peekLast();
                        if (map.get(prev) >= map.get(c)) {
                            calc(nums, ops);
                        } else {
                            break;
                        }
                    }
                    ops.addLast(c);
                }
            }
        }
        // 将剩余的计算完
        while (!ops.isEmpty()) calc(nums, ops);
        return nums.peekLast();
    }
    void calc(Deque<Integer> nums, Deque<Character> ops) {
        if (nums.isEmpty() || nums.size() < 2) return;
        if (ops.isEmpty()) return;
        int b = nums.pollLast(), a = nums.pollLast();
        char op = ops.pollLast();
        int ans = 0;
        if (op == '+') ans = a + b;
        else if (op == '-') ans = a - b;
        else if (op == '*') ans = a * b;
        else if (op == '/')  ans = a / b;
        else if (op == '^') ans = (int)Math.pow(a, b);
        else if (op == '%') ans = a % b;
        nums.addLast(ans);
    }
    boolean isNumber(char c) {
        return Character.isDigit(c);
    }
}