leetcode——计算器

最新推荐文章于 2024-09-08 19:30:00 发布

摸鱼混子

最新推荐文章于 2024-09-08 19:30:00 发布

阅读量540

点赞数

CC 4.0 BY-SA版权

分类专栏：我的leetcode刷题系列文章标签： leetcode 算法

本文链接：https://blog.csdn.net/qq_33789406/article/details/114666709

我的leetcode刷题系列专栏收录该内容

218 篇文章

订阅专栏

本文介绍了一个可以处理正负数、基本算术运算及括号的Solution类，展示了如何将字符串转换为逆波兰表达式并计算结果。重点讲解了处理空格、负数和运算符优先级的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

可以实现正数、负数、+、-、*、/、（、）的运算

class Solution {
    public int calculate(String s) {
        List<String> words = getInversePolishExpressions(handleSpacesAndNegativeNumber(s));
        return calculateResult(words);
    }

    private int calculateResult(List<String> words) {
        Stack<Integer> numbers = new Stack<>();
        for (String word : words) {
            if (isNumber(word.charAt(0))) {
                numbers.push(Integer.parseInt(word));
            } else {
                int second = numbers.pop();
                int first = numbers.pop();
                int res;
                switch (word) {
                    case "+":
                        res = first + second;
                        break;
                    case "-":
                        res = first - second;
                        break;
                    case "*":
                        res = first * second;
                        break;
                    case "/":
                        res = first / second;
                        break;
                    default:
                        res = -1;
                        break;
                }
                numbers.push(res);
            }
        }
        return numbers.peek();
    }

    private String handleSpacesAndNegativeNumber(String s) {
        s = s.replaceAll(" ", "");
        char[] letters = s.toCharArray();
        StringBuilder expression = new StringBuilder();
        for (char letter : letters) {
            if (letter == '+' || letter == '-') {
                if (expression.length() < 1 || expression.charAt(expression.length() - 1) == '(') {
                    expression.append('0');
                }
            }
            expression.append(letter);
        }
        return expression.toString();
    }

    private List<String> getInversePolishExpressions(String s) {
        List<String> words = new ArrayList<>();
        Stack<Character> operands = new Stack<>();
        char[] letters = s.toCharArray();
        operands.push('#');
        int len = letters.length;
        int i = 0;
        while (i < len) {
            if (isNumber(letters[i])) {
                StringBuilder number = new StringBuilder();
                while (i < len && isNumber(letters[i])) {
                    number.append(letters[i]);
                    i++;
                }
                words.add(number.toString());
            } else {
                if (letters[i] == '(') {
                    operands.push(letters[i]);
                } else if (letters[i] == ')') {
                    while (!operands.empty() && operands.peek() != '(') {
                        words.add(operands.pop() + "");
                    }
                    operands.pop();
                } else {
                    while (!operands.empty() && operands.peek() != '(' && getPriorityValue(letters[i]) <= getPriorityValue(operands.peek())) {
                        words.add(operands.pop() + "");
                    }
                    operands.push(letters[i]);
                }
                i++;
            }
        }
        while (operands.peek() != '#') {
            words.add(operands.pop() + "");
        }
        return words;
    }

    private int getPriorityValue(char c) {
        switch (c) {
            case '#':
                return 0;
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
            default:
                return -1;
        }
    }

    private boolean isNumber(char c) {
        return c >= '0' && c <= '9';
    }
}