LOADING

加载过慢请开启缓存 浏览器默认开启

前后缀表达式

2024/10/15 数据结构 数据结构 C语言 栈

概念定义

  1. 中缀表达式：操作符在操作数中间，就是平时我们计算识别的算术表达式，例如 3+4-5。

    计算方法：略。

  2. 前缀表达式（波兰表达式）：操作符在操作数的前面，比如 +-543。

    计算方法：遇到操作符挨着两个数字逆序计算然后求解消去，比如-54=4-5计算后得到+（-1）3=3-1=2。

  3. 后缀表达式（逆波兰表达式）：操作符在操作数的后面，比如 34+5-。

    计算方法：遇到操作符后挨着两个数字顺序计算然后求解消去，比如34+=3+4计算后得到75-=7-5=2。

算法思想

中缀表达式转前缀表达式：

  1. 我们需要初始两个栈：OPTR栈-寄存运算符（过渡栈），OPND栈-寄存操作数或运算符（最终栈）。
  2. 然后从右往左依次读入表达式字符，遵守以下规则：
    1. 如果读入的是操作数，压入OPND栈。
    2. 如果读入的是运算符：
      1. 如果是右括号')'，直接压入OPTR栈顶，因为这是优先级最高的。
      2. 如果是左括号'('，依次弹出OPTR栈中的运算符并压入OPND栈，直到OPTR栈顶元素为左括号'('，弹出结束。
      3. 如果是运算符，和当前OPTR栈顶元素做优先级比较：如果当前运算符优先级大于栈顶元素，直接压入OPTR栈顶；如果当前运算符优先级小于等于栈顶元素，将栈中大于当前运算符的元素依次压入OPND栈中直到遇到平级或低级。
  3. 重复以上步骤，直到表达式结束，OPND从栈顶到栈底的顺序为前缀表达式，OPTR栈顶为空。

中缀表达式转后缀表达式：

  1. 我们需要初始两个栈：OPTR栈-寄存运算符（过渡栈），OPND栈-寄存操作数或运算符（最终栈）。
  2. 然后从左往右依次读入表达式字符，遵守以下规则：
    1. 如果读入的是操作数，压入OPND栈。
    2. 如果读入的是运算符：
      1. 如果是左括号'('，直接压入OPTR栈顶，因为这是优先级最高的。
      2. 如果是右括号')'，依次弹出OPTR栈中的运算符并压入OPND栈，直到OPTR栈顶元素为左括号'('，弹出结束。
      3. 如果是运算符，和当前OPTR栈顶元素做优先级比较：如果当前运算符优先级大于栈顶元素，直接压入OPTR栈顶；如果当前运算符优先级小于等于栈顶元素，将栈中大于当前运算符的元素依次压入OPND栈中直到遇到平级或低级。
  3. 重复以上步骤，直到表达式结束，OPND从栈底到栈顶的顺序为后缀表达式，OPTR栈顶为空。

其实思想和中缀表达式求解一样，不过我们现在不能直接运算了，而是需要把字符保留罢了。

代码实现

代码写的很差，仅作记录不喜勿喷，但欢迎指点。

中缀表达式转前缀表达式

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

#define MAX_STACK_SIZE 100

// 判断运算符优先级
int precedence(char op) {
    switch (op) {
    case '+':
    case '-':
        return 1;
    case '*':
    case '/':
        return 2;
    default:
        return 0;
    }
}

// 执行运算
int applyOperator(char op, int a, int b) {
    switch (op) {
    case '+': return a + b;
    case '-': return a - b;
    case '*': return a * b;
    case '/':
        if (b == 0) {
            printf("错误: 除以零\n");
            exit(EXIT_FAILURE);
        }
        return a / b;
    default:
        printf("错误: 无效的运算符 '%c'\n", op);
        exit(EXIT_FAILURE);
    }
}

// 打印栈的内容, opndStack 为 char** 类型
void printStacks(char* optrStack, int optrTop, char** opndStack, int opndTop) {
    printf("OPTR栈: ");
    if (optrTop == -1) {
        printf("空");
    }
    else {
        for (int i = 0; i <= optrTop; i++) {
            printf("%c ", optrStack[i]);
        }
    }

    printf("\nOPND栈: ");
    if (opndTop == -1) {
        printf("空");
    }
    else {
        for (int i = 0; i <= opndTop; i++) {
            printf("%s ", opndStack[i]);
        }
    }
    printf("\n\n");
}

// 将运算符转换为字符串的函数
char* operatorToString(char op) {
    char* resultStr = (char*)malloc(2 * sizeof(char));
    if (!resultStr) {
        printf("内存分配失败\n");
        exit(EXIT_FAILURE);
    }
    resultStr[0] = op;
    resultStr[1] = '\0';
    return resultStr;
}

// 中缀表达式转前缀表达式
char** infixToPrefix(const char* infix) {
    // 初始化两个栈，这里的opnd栈存放字符串，而optr栈是运算符栈
    char* optrStack = (char*)malloc(MAX_STACK_SIZE * sizeof(char));
    char** opndStack = (char**)malloc(MAX_STACK_SIZE * sizeof(char*));

    if (!optrStack || !opndStack) {
        printf("内存分配失败\n");
        exit(EXIT_FAILURE);
    }

    // 初始化两个栈的指针
    int optrTop = -1;
    int opndTop = -1;

    int i = strlen(infix) - 1;
    char token;

    printf("中缀表达式: %s\n\n", infix);

    // 遍历表达式
    while (i >= 0) {
        token = infix[i];
        printf("读取字符：%c\n", token);

        // 跳过空格
        if (isspace(token)) {
            i--;
            continue;
        }

        // 如果是数字，处理多位数字
        if (isdigit(token)) {
            char* s = (char*)malloc(MAX_STACK_SIZE * sizeof(char));
            if (!s) {
                printf("内存分配失败\n");
                exit(EXIT_FAILURE);
            }
            int p = 0;
            while (i >= 0 && isdigit(infix[i])) {
                s[p++] = infix[i--];
            }
            s[p] = '\0';
            // 反转字符串
            for (int k = 0; k < p / 2; k++) {
                char temp = s[k];
                s[k] = s[p - 1 - k];
                s[p - 1 - k] = temp;
            }
            opndStack[++opndTop] = s;
            printf("将操作数 %s 压入 OPND 栈\n", s);
            printStacks(optrStack, optrTop, opndStack, opndTop);
            continue;
        }

        // 如果是右括号，直接压入 OPTR 栈
        if (token == ')') {
            if (optrTop >= MAX_STACK_SIZE - 1) {
                printf("错误: 运算符栈溢出\n");
                free(optrStack);
                for (int j = 0; j <= opndTop; j++) {
                    free(opndStack[j]);
                }
                free(opndStack);
                exit(EXIT_FAILURE);
            }
            optrStack[++optrTop] = token;
            printf("将 ')' 压入 OPTR 栈\n");
            printStacks(optrStack, optrTop, opndStack, opndTop);
            i--;
            continue;
        }

        // 如果是左括号，处理括号内的所有运算
        if (token == '(') {
            printf("遇到 '('，处理括号内的所有运算\n");
            while (optrTop >= 0 && optrStack[optrTop] != ')') {
                if (optrTop < 0 || opndTop < 1) {
                    printf("错误: 表达式不合法\n");
                    free(optrStack);
                    for (int j = 0; j <= opndTop; j++) {
                        free(opndStack[j]);
                    }
                    free(opndStack);
                    exit(EXIT_FAILURE);
                }
                char op = optrStack[optrTop--];
                char* resultStr = operatorToString(op);
                opndStack[++opndTop] = resultStr;
                printStacks(optrStack, optrTop, opndStack, opndTop);
            }
            if (optrTop >= 0) {
                optrTop--; // 弹出右括号
            }
            i--;
            continue;
        }

        // 如果是运算符，处理优先级
        while (optrTop >= 0 && precedence(optrStack[optrTop]) >= precedence(token)) {
            if (optrTop < 0 || opndTop < 1) {
                printf("错误: 表达式不合法\n");
                free(optrStack);
                for (int j = 0; j <= opndTop; j++) {
                    free(opndStack[j]);
                }
                free(opndStack);
                exit(EXIT_FAILURE);
            }
            char op = optrStack[optrTop--];
            char* resultStr = operatorToString(op);
            opndStack[++opndTop] = resultStr;
            printStacks(optrStack, optrTop, opndStack, opndTop);
        }

        // 优先级大于栈顶直接入栈
        if (optrTop >= MAX_STACK_SIZE - 1) {
            printf("错误: 运算符栈溢出\n");
            free(optrStack);
            for (int j = 0; j <= opndTop; j++) {
                free(opndStack[j]);
            }
            free(opndStack);
            exit(EXIT_FAILURE);
        }
        optrStack[++optrTop] = token;
        printf("将运算符 '%c' 压入 OPTR 栈\n", token);
        printStacks(optrStack, optrTop, opndStack, opndTop);

        i--;
    }

    // 处理剩余的运算符
    while (optrTop >= 0) {
        if (optrTop < 0 || opndTop < 1) {
            printf("错误: 表达式不合法\n");
            free(optrStack);
            for (int j = 0; j <= opndTop; j++) {
                free(opndStack[j]);
            }
            free(opndStack);
            exit(EXIT_FAILURE);
        }
        char op = optrStack[optrTop--];
        char* resultStr = operatorToString(op);
        opndStack[++opndTop] = resultStr;
        printStacks(optrStack, optrTop, opndStack, opndTop);
    }

    if (optrTop != -1) {
        printf("错误: 表达式不合法\n");
        free(optrStack);
        for (int j = 0; j <= opndTop; j++) {
            free(opndStack[j]);
        }
        free(opndStack);
        exit(EXIT_FAILURE);
    }

    char** prefix = (char**)malloc((MAX_STACK_SIZE + 1) * sizeof(char*));
    if (!prefix) {
        printf("内存分配失败\n");
        exit(EXIT_FAILURE);
    }
    for (int j = 0; j <= opndTop; j++) {
        prefix[j] = (char*)malloc(strlen(opndStack[opndTop - j]) + 1);
        if (!prefix[j]) {
            printf("内存分配失败\n");
            exit(EXIT_FAILURE);
        }
        strcpy(prefix[j], opndStack[opndTop - j]);
        free(opndStack[opndTop - j]);
    }
    prefix[opndTop + 1] = NULL;

    free(optrStack);
    free(opndStack);

    return prefix;
}

// 前缀表达式求值
int prefixExpressionCompute(char** prefix) {
    // 保存中间数字的栈
    int* stack = (int*)malloc(MAX_STACK_SIZE * sizeof(int));
    // 栈顶指针
    int top = -1;

    // 计算前缀表达式的长度
    int length = 0;
    while (prefix[length] != NULL) {
        length++;
    }

    // 从后向前遍历前缀表达式
    for (int i = length - 1; i >= 0; i--) {
        if (isdigit(prefix[i][0])) {
            stack[++top] = atoi(prefix[i]);
        }
        else {
            int a = stack[top--];
            int b = stack[top--];
            int result = applyOperator(prefix[i][0], a, b);
            stack[++top] = result;
        }
    }

    if (top != 0) {
        printf("错误: 表达式不合法\n");
        free(stack);
        exit(EXIT_FAILURE);
    }
    int result = stack[top];
    free(stack);
    return result;
}

int main() {
    const char* expression = "5+2*5+(60/3+7*3)+2";
    char** prefix = infixToPrefix(expression);
    printf("前缀表达式: ");
    for (int i = 0; prefix[i] != NULL; i++) {
        printf("%s ", prefix[i]);
    }
    printf("\n");
    printf("前缀表达式求值: %d\n", prefixExpressionCompute(prefix));
    for (int i = 0; prefix[i] != NULL; i++) {
        free(prefix[i]);
    }
    free(prefix);
    return 0;
}

输出结果

中缀表达式: 5+2*5+(60/3+7*3)+2

读取字符：2
将操作数 2 压入 OPND 栈
OPTR栈: 空
OPND栈: 2

读取字符：+
将运算符 '+' 压入 OPTR 栈
OPTR栈: +
OPND栈: 2

读取字符：)
将 ')' 压入 OPTR 栈
OPTR栈: + )
OPND栈: 2

读取字符：3
将操作数 3 压入 OPND 栈
OPTR栈: + )
OPND栈: 2 3

读取字符：*
将运算符 '*' 压入 OPTR 栈
OPTR栈: + ) *
OPND栈: 2 3

读取字符：7
将操作数 7 压入 OPND 栈
OPTR栈: + ) *
OPND栈: 2 3 7

读取字符：+
OPTR栈: + )
OPND栈: 2 3 7 *

将运算符 '+' 压入 OPTR 栈
OPTR栈: + ) +
OPND栈: 2 3 7 *

读取字符：3
将操作数 3 压入 OPND 栈
OPTR栈: + ) +
OPND栈: 2 3 7 * 3

读取字符：/
将运算符 '/' 压入 OPTR 栈
OPTR栈: + ) + /
OPND栈: 2 3 7 * 3

读取字符：0
将操作数 60 压入 OPND 栈
OPTR栈: + ) + /
OPND栈: 2 3 7 * 3 60

读取字符：(
遇到 '('，处理括号内的所有运算
OPTR栈: + ) +
OPND栈: 2 3 7 * 3 60 /

OPTR栈: + )
OPND栈: 2 3 7 * 3 60 / +

读取字符：+
OPTR栈: 空
OPND栈: 2 3 7 * 3 60 / + +

将运算符 '+' 压入 OPTR 栈
OPTR栈: +
OPND栈: 2 3 7 * 3 60 / + +

读取字符：5
将操作数 5 压入 OPND 栈
OPTR栈: +
OPND栈: 2 3 7 * 3 60 / + + 5

读取字符：*
将运算符 '*' 压入 OPTR 栈
OPTR栈: + *
OPND栈: 2 3 7 * 3 60 / + + 5

读取字符：2
将操作数 2 压入 OPND 栈
OPTR栈: + *
OPND栈: 2 3 7 * 3 60 / + + 5 2

读取字符：+
OPTR栈: +
OPND栈: 2 3 7 * 3 60 / + + 5 2 *

OPTR栈: 空
OPND栈: 2 3 7 * 3 60 / + + 5 2 * +

将运算符 '+' 压入 OPTR 栈
OPND栈: 2 3 7 * 3 60 / + + 5 2 * +

读取字符：5
将操作数 5 压入 OPND 栈
OPTR栈: +
OPND栈: 2 3 7 * 3 60 / + + 5 2 * + 5

OPTR栈: 空
OPND栈: 2 3 7 * 3 60 / + + 5 2 * + 5 +

前缀表达式: + 5 + * 2 5 + + / 60 3 * 7 3 2
前缀表达式求值: 58

中缀表达式转后缀表达式

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

#define MAX_STACK_SIZE 100

// 判断运算符优先级
int precedence(char op) {
    switch (op) {
    case '+':
    case '-':
        return 1;
    case '*':
    case '/':
        return 2;
    default:
        return 0;
    }
}

// 执行运算
int applyOperator(char op, int a, int b) {
    switch (op) {
    case '+': return a + b;
    case '-': return a - b;
    case '*': return a * b;
    case '/':
        if (b == 0) {
            printf("错误: 除以零\n");
            exit(EXIT_FAILURE);
        }
        return a / b;
    default:
        printf("错误: 无效的运算符 '%c'\n", op);
        exit(EXIT_FAILURE);
    }
}

// 打印栈的内容, opndStack 为 char** 类型
void printStacks(char* optrStack, int optrTop, char** opndStack, int opndTop) {
    printf("OPTR栈: ");
    if (optrTop == -1) {
        printf("空");
    }
    else {
        for (int i = 0; i <= optrTop; i++) {
            printf("%c ", optrStack[i]);
        }
    }

    printf("\nOPND栈: ");
    if (opndTop == -1) {
        printf("空");
    }
    else {
        for (int i = 0; i <= opndTop; i++) {
            printf("%s ", opndStack[i]);
        }
    }
    printf("\n\n");
}

// 将运算符转换为字符串的函数
char* operatorToString(char op) {
    char* resultStr = (char*)malloc(2 * sizeof(char));
    if (!resultStr) {
        printf("内存分配失败\n");
        exit(EXIT_FAILURE);
    }
    resultStr[0] = op;
    resultStr[1] = '\0';
    return resultStr;
}

// 中缀表达式转后缀表达式
char** infixToPostfix(const char* infix) {
    // 初始化两个栈，这里的opnd栈存放字符串，而optr栈是运算符栈
    char* optrStack = (char*)malloc(MAX_STACK_SIZE * sizeof(char));
    char** opndStack = (char**)malloc(MAX_STACK_SIZE * sizeof(char*));

    if (!optrStack || !opndStack) {
        printf("内存分配失败\n");
        exit(EXIT_FAILURE);
    }

    // 初始化两个栈的指针
    int optrTop = -1;
    int opndTop = -1;

    int i = 0;
    char token;

    printf("中缀表达式: %s\n\n", infix);

    // 遍历表达式
    while ((token = infix[i]) != '\0') {
        printf("读取字符：%c\n", token);

        // 跳过空格
        if (isspace(token)) {
            i++;
            continue;
        }

        // 如果是数字，处理多位数字
        if (isdigit(token)) {
            char* s = (char*)malloc(MAX_STACK_SIZE * sizeof(char));
            if (!s) {
                printf("内存分配失败\n");
                exit(EXIT_FAILURE);
            }
            int p = 0; // 字符串指针
            while (isdigit(infix[i])) {
                s[p++] = infix[i++];
            }
            s[p] = '\0'; // 在字符串末尾添加\0
            opndStack[++opndTop] = s;
            printf("将操作数 %s 压入 OPND 栈\n", s);
            printStacks(optrStack, optrTop, opndStack, opndTop);
            continue;
        }

        // 如果是左括号，直接压入 OPTR 栈
        if (token == '(') {
            if (optrTop >= MAX_STACK_SIZE - 1) {
                printf("错误: 运算符栈溢出\n");
                free(optrStack);
                for (int j = 0; j <= opndTop; j++) {
                    free(opndStack[j]);
                }
                free(opndStack);
                exit(EXIT_FAILURE);
            }
            optrStack[++optrTop] = token;
            printf("将 '(' 压入 OPTR 栈\n");
            printStacks(optrStack, optrTop, opndStack, opndTop);
            i++;
            continue;
        }

        // 如果是右括号，处理括号内的所有运算
        if (token == ')') {
            printf("遇到 ')'，处理括号内的所有运算\n");
            while (optrTop >= 0 && optrStack[optrTop] != '(') {
                if (optrTop < 0 || opndTop < 1) {
                    printf("错误: 表达式不合法\n");
                    free(optrStack);
                    for (int j = 0; j <= opndTop; j++) {
                        free(opndStack[j]);
                    }
                    free(opndStack);
                    exit(EXIT_FAILURE);
                }
                char op = optrStack[optrTop--];
                char* resultStr = operatorToString(op);
                opndStack[++opndTop] = resultStr;
                printStacks(optrStack, optrTop, opndStack, opndTop);
            }
            if (optrTop >= 0) {
                optrTop--; // 弹出左括号
            }
            i++;
            continue;
        }

        // 如果是运算符，处理优先级
        while (optrTop >= 0 && precedence(optrStack[optrTop]) >= precedence(token)) {
            if (optrTop < 0 || opndTop < 1) {
                printf("错误: 表达式不合法\n");
                free(optrStack);
                for (int j = 0; j <= opndTop; j++) {
                    free(opndStack[j]);
                }
                free(opndStack);
                exit(EXIT_FAILURE);
            }
            char op = optrStack[optrTop--];
            char* resultStr = operatorToString(op);
            opndStack[++opndTop] = resultStr;
            printStacks(optrStack, optrTop, opndStack, opndTop);
        }

        // 优先级大于栈顶直接入栈
        if (optrTop >= MAX_STACK_SIZE - 1) {
            printf("错误: 运算符栈溢出\n");
            free(optrStack);
            for (int j = 0; j <= opndTop; j++) {
                free(opndStack[j]);
            }
            free(opndStack);
            exit(EXIT_FAILURE);
        }
        optrStack[++optrTop] = token;
        printf("将运算符 '%c' 压入 OPTR 栈\n", token);
        printStacks(optrStack, optrTop, opndStack, opndTop);

        i++;
    }

    // 处理剩余的运算符
    while (optrTop >= 0) {
        if (optrTop < 0 || opndTop < 1) {
            printf("错误: 表达式不合法\n");
            free(optrStack);
            for (int j = 0; j <= opndTop; j++) {
                free(opndStack[j]);
            }
            free(opndStack);
            exit(EXIT_FAILURE);
        }
        char op = optrStack[optrTop--];
        char* resultStr = operatorToString(op);
        opndStack[++opndTop] = resultStr;
        printStacks(optrStack, optrTop, opndStack, opndTop);
    }

    if (optrTop != -1) {
        printf("错误: 表达式不合法\n");
        free(optrStack);
        for (int j = 0; j <= opndTop; j++) {
            free(opndStack[j]);
        }
        free(opndStack);
        exit(EXIT_FAILURE);
    }

    char** postfix = (char**)malloc((MAX_STACK_SIZE + 1) * sizeof(char*));
    if (!postfix) {
        printf("内存分配失败\n");
        exit(EXIT_FAILURE);
    }
    for (int j = 0; j <= opndTop; j++) {
        postfix[j] = (char*)malloc(strlen(opndStack[j]) + 1);
        if (!postfix[j]) {
            printf("内存分配失败\n");
            exit(EXIT_FAILURE);
        }
        strcpy(postfix[j], opndStack[j]);
        free(opndStack[j]);
    }
    postfix[opndTop + 1] = NULL;

    free(optrStack);
    free(opndStack);

    return postfix;
}

// 后缀表达式求值
int postfixExpressionCompute(char** postfix) {
    // 保存中间数字的栈
    int* stack = (int*)malloc(MAX_STACK_SIZE * sizeof(int));
    // 栈顶指针
    int top = -1;

    for (int i = 0; postfix[i] != NULL; i++) {
        if (isdigit(postfix[i][0])) {
            stack[++top] = atoi(postfix[i]);
        }
        else {
            int b = stack[top--];
            int a = stack[top--];
            int result = applyOperator(postfix[i][0], a, b);
            stack[++top] = result;
        }
    }

    if (top != 0) {
        printf("错误: 表达式不合法\n");
        free(stack);
        exit(EXIT_FAILURE);
    }
    int result = stack[top];
    free(stack);
    return result;
}

int main() {
    const char* expression = "5+2*5+(60/3+7*3)+2";
    char** postfix = infixToPostfix(expression);
    printf("后缀表达式: ");
    for (int i = 0; postfix[i] != NULL; i++) {
        printf("%s ", postfix[i]);
    }
    printf("\n");
    printf("后缀表达式求值: %d\n", postfixExpressionCompute(postfix));
    for (int i = 0; postfix[i] != NULL; i++) {
        free(postfix[i]);
    }
    free(postfix);
    return 0;
}

输出结果

中缀表达式: 5+2*5+(60/3+7*3)+2

读取字符：5
将操作数 5 压入 OPND 栈
OPTR栈: 空
OPND栈: 5 

读取字符：+
将运算符 '+' 压入 OPTR 栈
OPTR栈: + 
OPND栈: 5 

读取字符：2
将操作数 2 压入 OPND 栈
OPTR栈: + 
OPND栈: 5 2 

读取字符：*
将运算符 '*' 压入 OPTR 栈
OPTR栈: + *
OPND栈: 5 2

读取字符：5
将操作数 5 压入 OPND 栈
OPTR栈: + *
OPND栈: 5 2 5

读取字符：+
OPTR栈: +
OPND栈: 5 2 5 *

OPTR栈: 空
OPND栈: 5 2 5 * +

将运算符 '+' 压入 OPTR 栈
OPTR栈: +
OPND栈: 5 2 5 * +

读取字符：(
将 '(' 压入 OPTR 栈
OPTR栈: + (
OPND栈: 5 2 5 * +

读取字符：6
将操作数 60 压入 OPND 栈
OPTR栈: + (
OPND栈: 5 2 5 * + 60

读取字符：/
将运算符 '/' 压入 OPTR 栈
OPTR栈: + ( /
OPND栈: 5 2 5 * + 60

读取字符：3
将操作数 3 压入 OPND 栈
OPTR栈: + ( /
OPND栈: 5 2 5 * + 60 3

读取字符：+
OPTR栈: + (
OPND栈: 5 2 5 * + 60 3 /

将运算符 '+' 压入 OPTR 栈
OPTR栈: + ( +
OPND栈: 5 2 5 * + 60 3 /

读取字符：7
将操作数 7 压入 OPND 栈
OPTR栈: + ( +
OPND栈: 5 2 5 * + 60 3 / 7

读取字符：*
将运算符 '*' 压入 OPTR 栈
OPTR栈: + ( + *
OPND栈: 5 2 5 * + 60 3 / 7

读取字符：3
将操作数 3 压入 OPND 栈
OPTR栈: + ( + *
OPND栈: 5 2 5 * + 60 3 / 7 3

读取字符：)
遇到 ')'，处理括号内的所有运算
OPTR栈: + ( +
OPND栈: 5 2 5 * + 60 3 / 7 3 *

OPTR栈: + (
OPND栈: 5 2 5 * + 60 3 / 7 3 * +

读取字符：+
OPTR栈: 空
OPND栈: 5 2 5 * + 60 3 / 7 3 * + +

将运算符 '+' 压入 OPTR 栈
OPTR栈: +
OPND栈: 5 2 5 * + 60 3 / 7 3 * + +

读取字符：2
将操作数 2 压入 OPND 栈
OPTR栈: +
OPND栈: 5 2 5 * + 60 3 / 7 3 * + + 2

OPTR栈: 空
OPND栈: 5 2 5 * + 60 3 / 7 3 * + + 2 +

后缀表达式: 5 2 5 * + 60 3 / 7 3 * + + 2 +
后缀表达式求值: 58