程序员必备：高效实现计算器优先级运算

程序员必备：高效实现计算器优先级运算

引用

CSDN

等

10

来源

1.

https://blog.csdn.net/qq_34704689/article/details/136741392

2.

https://blog.csdn.net/Gassuih/article/details/114883968

3.

https://blog.csdn.net/2301_78146269/article/details/136381887

4.

https://blog.csdn.net/qq_41529009/article/details/90452755

5.

https://zhuanlan.zhihu.com/p/689892161

6.

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Operator_precedence#%E5%B0%9D%E8%AF%95%E4%B8%80%E4%B8%8B

7.

https://cloud.tencent.com/developer/article/2406703

8.

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Operator_precedence#%E7%A4%BA%E4%BE%8B

9.

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Operator_precedence#%E4%BC%98%E5%85%88%E7%BA%A7%E5%92%8C%E7%BB%93%E5%90%88%E6%80%A7

10.

https://q.shanyue.tech/base

在编程面试和实际开发中，实现一个功能完备的计算器是程序员必备的技能之一。本文将带你从零开始，逐步掌握计算器算法的核心实现要点，包括字符串转换、优先级处理和优化方案。无论你是面试准备还是项目开发，这些知识都将为你提供坚实的基础。

在数学运算中，运算符的优先级和结合性决定了计算的顺序。例如，乘除运算的优先级高于加减运算，而括号可以改变默认的运算顺序。理解这些基本概念是实现计算器算法的前提。

字符串转整数

首先，我们需要将输入的字符串转换为可以进行计算的整数。这一步看似简单，却是整个算法的基础。

String s = "234";
int res = 0;
for (int i = 0; i < s.length(); i++) {
    res = res * 10 + (s.charAt(i) - '0');
}

处理加减法

接下来，我们处理只包含加减法的表达式。核心思路是将数字和符号分别存储，然后依次计算。

String s = "1-12+3";
Stack<Integer> stack = new Stack<>();
int num = 0;
char sign = '+';
for (int i = 0; i < s.length(); i++) {
    char c = s.charAt(i);
    if (Character.isDigit(c))
        num = num * 10 + (c - '0');
    if (!Character.isDigit(c) || i == s.length() - 1) {
        switch (sign) {
            case '+':
                stack.push(num);
                break;
            case '-':
                stack.push(-num);
                break;
        }
        sign = c;
        num = 0;
    }
}
int res = 0;
while (!stack.isEmpty()) {
    res += stack.peek();
    stack.pop();
}

处理乘除法

在加减法的基础上，我们进一步处理乘除法。关键在于更新栈中的元素，以反映乘除运算的结果。

String s = "2-3*4+5";
Stack<Integer> stack = new Stack<>();
int num = 0;
char sign = '+';
for (int i = 0; i < s.length(); i++) {
    char c = s.charAt(i);
    if (Character.isDigit(c))
        num = num * 10 + (c - '0');
    if ((!Character.isDigit(c) && c != ' ') || i == s.length() - 1) {
        int pre = 0;
        switch (sign) {
            case '+':
                stack.push(num);
                break;
            case '-':
                stack.push(-num);
                break;
            case '*':
                pre = stack.peek();
                stack.pop();
                stack.push(pre * num);
                break;
            case '/':
                pre = stack.peek();
                stack.pop();
                stack.push(pre / num);
                break;
        }
        sign = c;
        num = 0;
    }
}
int res = 0;
while (!stack.isEmpty()) {
    res += stack.peek();
    stack.pop();
}

处理括号

最后，我们处理括号内的表达式。这通常需要递归调用上述算法，将括号内的结果作为一个整体参与后续计算。

在掌握了基本实现后，我们可以进一步优化代码结构。使用函数指针和函数指针数组，可以使代码更加简洁和高效。

基于函数指针的优化

#include<stdio.h>
void menu() {
    printf("1.加法  2.减法  3.乘法  4.除法  0.退出游戏");
}
int cal(int(*pf)(int x, int y)) {
    int x = 0;
    int y = 0;
    int ret = 0;
    printf("请输入两个操作数>");
    scanf_s("%d %d", &x, &y);
    printf("结果是：%d\n", pf(x, y));
}
int add(int x, int y) {
    return x + y;
}
int sub(int x, int y) {
    return x - y;
}
int mul(int x, int y) {
    return x * y;
}
int div(int x, int y) {
    return x / y;
}
int main() {
    int input = 0;
    do {
        menu();
        printf("请选择>");
        scanf_s("%d", &input);
        switch (input) {
            case 1:
                cal(add);
                break;
            case 2:
                cal(sub);
                break;
            case 3:
                cal(mul);
                break;
            case 4:
                cal(div);
                break;
            case 0:
                printf("退出游戏\n");
                break;
            default:
                printf("输入错误\n");
        }
    } while (input);
}

基于函数指针数组的优化

#include<stdio.h>
void menu() {
    printf("1.加法  2.减法  3.乘法  4.除法  0.退出游戏");
}
int add(int x, int y) {
    return x + y;
}
int sub(int x, int y) {
    return x - y;
}
int mul(int x, int y) {
    return x * y;
}
int div(int x, int y) {
    return x / y;
}
int main() {
    int (*pfarr[])(int, int) = { 0,add,sub,mul,div };
    int input = 0;
    do {
        menu();
        printf("请选择>");
        scanf_s("%d", &input);
        if (input > 0 && input < 5) {
            int x = 0;
            int y = 0;
            printf("请输入两个操作数>");
            scanf_s("%d %d", &x, &y);
            printf("结果是：%d\n", pfarr[input](x, y));
        }
    } while (input);
}

通过使用函数指针数组，我们避免了复杂的switch语句，使代码结构更加清晰和简洁。

掌握计算器算法的实现，不仅能帮助你应对面试中的技术挑战，还能为实际开发中的复杂运算提供解决方案。从基本的字符串转换到优先级处理，再到高级的函数指针优化，这些知识将为你的编程技能增添重要的一环。建议读者亲自实践上述代码，深入理解每个步骤的实现原理，为未来的开发工作打下坚实的基础。