栈技巧之Note001-前缀和中缀及后缀表达式

最新推荐文章于 2023-05-30 12:03:20 发布
最新推荐文章于 2023-05-30 12:03:20 发布
阅读量635 收藏 8
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 栈 前缀表达式 中缀表达式 后缀表达式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/124357465
版权

前缀表达式、中缀表达式、后缀表达式的转换

前缀、中缀和后缀表达式概念

前缀、中缀和后缀表达式是对表达式的不同记法，其区别在于运算符相对于操作数的位置不同，其中前缀表达式的运算符位于操作数的前面，后缀表达式的运算符位于操作数的后面。例如：

  • 中缀表达式：1+(2+3)*4-5。
  • 前缀表达式：-+1*+2345。
  • 后缀表达式：123+4*+5-。

我们常用的就是中缀表达式，对于人很容易理解，但是对于计算机来说中缀表达式很难理解，因此在计算表达式的值时，需要先将中缀表达式转换成前缀或后缀表达式，然后再进行求值，对于计算机来说，计算前缀或后缀表达式的值非常简单。总结：

  • 前缀、中缀、后缀是根据运算符与操作数的相对位置来划分的。
  • 中缀表达式符合人的计算习惯，而前缀和后缀表达式适合计算机计算。
  • 前缀表达式和后缀表达式计算的时候都是从一个方向扫描表达式，遇到数字压入栈，遇到运算符弹出栈顶的两个数进行运算并将结果入栈，重复直到结束。
  • 前缀和后缀表达式已经内在地包含运算顺序，因此不用括号来确定优先级。

前缀表达式的计算机求值

算法思想

算法思想：从右往左扫描表达式，遇到数字时，将数字压入栈；遇到运算符时，弹出栈顶的两个数字，用运算符对它们进行相应的计算，并且将结果压入栈。重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。

示例

例如，有前缀表达式：-*+3456。求值步骤如下：

  • （1）从右往左扫描，将 6、5、4、3 压入栈中。
  • （2）然后遇到 + 运算符，弹出栈顶的两个数字，即弹出 3 和 4（其中 3 为栈顶元素、4 为次顶元素），计算出 3+4 的值，得到 7，然后再将 7 压入栈中。
  • （3）接下来是 * 运算符，弹出栈顶的两个数字，即弹出 7 和 5，计算出 7*5 的值，得到 35，将 35 压入栈中。
  • （4）最后是 - 运算符，弹出栈顶的两个数字，即弹出 35 和 6，计算出 35-6 的值，得到 29， 由此得出最终结果。

实现代码

求前缀表达式的核心代码如下：

/**
 * 根据运算符计算两数的结果
 * @param sign 运算符
 * @param a 第一个数
 * @param b 第二个数
 * @return 两数计算的结果
 */
int evaluate(char sign, int a, int b) {
    int result = 0;
    switch (sign) {
        case '+':
            result = a + b;
            break;
        case '-':
            result = a - b;
            break;
        case '*':
            result = a * b;
            break;
        case '/':
            result = a / b;
            break;
        case '%':
            result = a % b;
            break;
        default:
            printf("非可计算的运算符：%c", sign);
            break;
    }
    return result;
}

/**
 * 计算前缀表达式
 * @param exps 前缀表达式，以 '\0' 字符结束
 * @param n 字符数组的实际字符个数
 * @return 表达式的计算结果
 */
int evaluatePrefixExpression(char exps[], int n) {
    // 0.解题需要用到栈，所以创建顺序栈并初始化栈
    SeqStack stack;
    init(&stack);

    // 1.从右往左扫描前缀表达式，所以要倒序遍历字符数组
    for (int i = n - 1; i >= 0; i--) {
        // 1.1 如果当前字符是数字字符
        if (exps[i] >= '0' && exps[i] <= '9') {
            // 1.1.1 则将该数字压入栈中，注意数字字符要转换成数字才能存入栈中，而数字字符要转换成数字可以用数字字符减去'0'字符即可得到所对应的数字
            push(&stack, exps[i] - '0');
        }
        // 1.2 如果当字符不是数字字符，而是运算符
        else {
            // 1.2.1 那么弹出栈顶两个数字，用 a 和 b 来保存
            int a, b;
            pop(&stack, &a);
            pop(&stack, &b);
            // 1.2.2 根据运算符调用函数计算 a 和 b 的结果
            int result = evaluate(exps[i], a, b);
            // 1.2.3 将计算结果压入栈中
            push(&stack, result);
        }
    }

    // 2.最终结果也是存在栈中的，就算栈顶元素，所以获得栈顶元素返回即可
    int top;
    getTop(stack, &top);
    return top;
}

完整代码如下：

#include <stdio.h>

/**
 * 顺序栈最大存储的元素个数
 */
#define MAXSIZE 100

/**
 * 顺序栈结构体定义
 */
typedef struct {
    /**
     * 数据域，数组，用来存储栈中元素
     */
    int data[MAXSIZE];
    /**
     * 指针域，表示栈顶指针，实际上就是数组下标
     */
    int top;
} SeqStack;

/**
 * 初始化顺序栈，即将栈顶指针指向 -1 表示空栈
 * @param stack 顺序栈
 */
void init(SeqStack *stack) {
    // 设定让栈顶指针指向 -1 表示为栈空
    stack->top = -1;
}

/**
 * 将元素入栈
 * @param stack 顺序栈
 * @param ele 元素值
 * @return 如果栈满则返回 0 表示入栈失败；如果插入成功则返回 1
 */
int push(SeqStack *stack, int ele) {
    // 1.参数校验，如果栈满则不能入栈元素
    if (stack->top == MAXSIZE - 1) {
        // 如果栈满，则返回 0，表示不能入栈
        return 0;
    }
    // 2.先将栈顶指针加一，指向新空数组位置
    stack->top++;
    // 3.将新元素值填充到新位置中
    stack->data[stack->top] = ele;
    return 1;
}

/**
 * 将元素出栈
 * @param stack 顺序栈
 * @param ele 用来保存出栈的元素
 * @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
 */
int pop(SeqStack *stack, int *ele) {
    // 1.参数校验，栈空不能出栈
    if (stack->top == -1) {
        // 栈空，没有元素可出栈
        return 0;
    }
    // 2.用 ele 来保存顺序栈栈顶元素
    *ele = stack->data[stack->top];
    // 3.然后栈顶指针减一，表示出栈一个元素
    stack->top--;
    return 1;
}

/**
 * 获取栈顶元素，但不出栈
 * @param stack 顺序栈
 * @param ele 用来保存出栈元素
 * @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
 */
int getTop(SeqStack stack, int *ele) {
    // 1.参数校验，如果栈空则不能出栈
    if (stack.top == -1) {
        // 栈空，没有元素可出栈
        return 0;
    }
    // 2.保存栈顶元素返回
    *ele = stack.data[stack.top];
    return 1;
}

/**
 * 根据运算符计算两数的结果
 * @param sign 运算符
 * @param a 第一个数
 * @param b 第二个数
 * @return 两数计算的结果
 */
int evaluate(char sign, int a, int b) {
    int result = 0;
    switch (sign) {
        case '+':
            result = a + b;
            break;
        case '-':
            result = a - b;
            break;
        case '*':
            result = a * b;
            break;
        case '/':
            result = a / b;
            break;
        case '%':
            result = a % b;
            break;
        default:
            printf("非可计算的运算符：%c", sign);
            break;
    }
    return result;
}

/**
 * 计算前缀表达式
 * @param exps 前缀表达式，以 '\0' 字符结束
 * @param n 字符数组的实际字符个数
 * @return 表达式的计算结果
 */
int evaluatePrefixExpression(char exps[], int n) {
    // 0.解题需要用到栈，所以创建顺序栈并初始化栈
    SeqStack stack;
    init(&stack);

    // 1.从右往左扫描前缀表达式，所以要倒序遍历字符数组
    for (int i = n - 1; i >= 0; i--) {
        // 1.1 如果当前字符是数字字符
        if (exps[i] >= '0' && exps[i] <= '9') {
            // 1.1.1 则将该数字压入栈中，注意数字字符要转换成数字才能存入栈中，而数字字符要转换成数字可以用数字字符减去'0'字符即可得到所对应的数字
            push(&stack, exps[i] - '0');
        }
        // 1.2 如果当字符不是数字字符，而是运算符
        else {
            // 1.2.1 那么弹出栈顶两个数字，用 a 和 b 来保存
            int a, b;
            pop(&stack, &a);
            pop(&stack, &b);
            // 1.2.2 根据运算符调用函数计算 a 和 b 的结果
            int result = evaluate(exps[i], a, b);
            // 1.2.3 将计算结果压入栈中
            push(&stack, result);
        }
    }

    // 2.最终结果也是存在栈中的，就算栈顶元素，所以获得栈顶元素返回即可
    int top;
    getTop(stack, &top);
    return top;
}

int main() {
    char prefixExp[] = "-*+3456";
    int n = 7;

    int result;
    result = evaluatePrefixExpression(prefixExp, n);
    printf("前缀表达式计算结果：%d", result);
}

后缀表达式的计算机求值

算法思想

算法思想：与前缀表达式的计算类似，只是顺序是从左向右扫描表达式。如果遇到数字，则将数字压入栈中；如果遇到运算符，则弹出栈顶的两个数字，用运算符对它们做相应的计算，并且将计算结果压入栈中。重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果。

示例

例如，有后缀表达式：34+5*6-。求值步骤如下：

  • （1）从左往右扫描，将 3 和 4 压入栈中。
  • （2）遇到 + 运算符，因此弹出栈顶的两个元素，分别是 3 和 4（其中 4 是栈顶元素、3 是次栈顶元素），计算 3+4 的值，得到结果 7，再将 7 入栈。
  • （3）遇到数字 5，然后将 5 入栈。
  • （4）接下来是 * 字符，因此弹出栈顶的两个元素，分别是 5 和 7，计算 5*7 的值，得到结果 35，将 35 入栈。
  • （5）遇到数字 6，然后将 6 入栈。
  • （6）最后是 - 运算符，计算出 6-35 的值，即 -29，由此得出最终结果。

实现代码

求后缀表达式的核心代码如下：

/**
 * 根据运算符计算两数的结果
 * @param sign 运算符
 * @param a 第一个数
 * @param b 第二个数
 * @return 两数计算的结果
 */
int evaluate(char sign, int a, int b) {
    int result = 0;
    switch (sign) {
        case '+':
            result = a + b;
            break;
        case '-':
            result = a - b;
            break;
        case '*':
            result = a * b;
            break;
        case '/':
            result = a / b;
            break;
        case '%':
            result = a % b;
            break;
        default:
            printf("非可计算的运算符：%c", sign);
            break;
    }
    return result;
}

/**
 * 计算前缀表达式
 * @param exps 前缀表达式，以 '\0' 字符结束
 * @param n 字符数组的实际字符个数
 * @return 表达式的计算结果
 */
int evaluateSuffixExpression(char exps[], int n) {
    // 0.解题需要用到栈，所以创建顺序栈并初始化栈
    SeqStack stack;
    init(&stack);

    // 1.从左往右扫描后缀表达式，所以要正序遍历字符数组
    for (int i = 0; i < n; i++) {
        // 1.1 如果当前字符是数字字符
        if (exps[i] >= '0' && exps[i] <= '9') {
            // 1.1.1 则将该数字压入栈中，注意数字字符要转换成数字才能存入栈中，而数字字符要转换成数字可以用数字字符减去'0'字符即可得到所对应的数字
            push(&stack, exps[i] - '0');
        }
        // 1.2 如果当字符不是数字字符，而是运算符
        else {
            // 1.2.1 那么弹出栈顶两个数字，用 a 和 b 来保存
            int a, b;
            pop(&stack, &a);
            pop(&stack, &b);
            // 1.2.2 根据运算符调用函数计算 a 和 b 的结果
            int result = evaluate(exps[i], a, b);
            // 1.2.3 将计算结果压入栈中
            push(&stack, result);
        }
    }

    // 2.最终结果也是存在栈中的，就算栈顶元素，所以获得栈顶元素返回即可
    int top;
    getTop(stack, &top);
    return top;
}

完整代码如下：

#include <stdio.h>

/**
 * 顺序栈最大存储的元素个数
 */
#define MAXSIZE 100

/**
 * 顺序栈结构体定义
 */
typedef struct {
    /**
     * 数据域，数组，用来存储栈中元素
     */
    int data[MAXSIZE];
    /**
     * 指针域，表示栈顶指针，实际上就是数组下标
     */
    int top;
} SeqStack;

/**
 * 初始化顺序栈，即将栈顶指针指向 -1 表示空栈
 * @param stack 顺序栈
 */
void init(SeqStack *stack) {
    // 设定让栈顶指针指向 -1 表示为栈空
    stack->top = -1;
}

/**
 * 将元素入栈
 * @param stack 顺序栈
 * @param ele 元素值
 * @return 如果栈满则返回 0 表示入栈失败；如果插入成功则返回 1
 */
int push(SeqStack *stack, int ele) {
    // 1.参数校验，如果栈满则不能入栈元素
    if (stack->top == MAXSIZE - 1) {
        // 如果栈满，则返回 0，表示不能入栈
        return 0;
    }
    // 2.先将栈顶指针加一，指向新空数组位置
    stack->top++;
    // 3.将新元素值填充到新位置中
    stack->data[stack->top] = ele;
    return 1;
}

/**
 * 将元素出栈
 * @param stack 顺序栈
 * @param ele 用来保存出栈的元素
 * @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
 */
int pop(SeqStack *stack, int *ele) {
    // 1.参数校验，栈空不能出栈
    if (stack->top == -1) {
        // 栈空，没有元素可出栈
        return 0;
    }
    // 2.用 ele 来保存顺序栈栈顶元素
    *ele = stack->data[stack->top];
    // 3.然后栈顶指针减一，表示出栈一个元素
    stack->top--;
    return 1;
}

/**
 * 获取栈顶元素，但不出栈
 * @param stack 顺序栈
 * @param ele 用来保存出栈元素
 * @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
 */
int getTop(SeqStack stack, int *ele) {
    // 1.参数校验，如果栈空则不能出栈
    if (stack.top == -1) {
        // 栈空，没有元素可出栈
        return 0;
    }
    // 2.保存栈顶元素返回
    *ele = stack.data[stack.top];
    return 1;
}

/**
 * 根据运算符计算两数的结果
 * @param sign 运算符
 * @param a 第一个数
 * @param b 第二个数
 * @return 两数计算的结果
 */
int evaluate(char sign, int a, int b) {
    int result = 0;
    switch (sign) {
        case '+':
            result = a + b;
            break;
        case '-':
            result = a - b;
            break;
        case '*':
            result = a * b;
            break;
        case '/':
            result = a / b;
            break;
        case '%':
            result = a % b;
            break;
        default:
            printf("非可计算的运算符：%c", sign);
            break;
    }
    return result;
}

/**
 * 计算前缀表达式
 * @param exps 前缀表达式，以 '\0' 字符结束
 * @param n 字符数组的实际字符个数
 * @return 表达式的计算结果
 */
int evaluateSuffixExpression(char exps[], int n) {
    // 0.解题需要用到栈，所以创建顺序栈并初始化栈
    SeqStack stack;
    init(&stack);

    // 1.从左往右扫描后缀表达式，所以要正序遍历字符数组
    for (int i = 0; i < n; i++) {
        // 1.1 如果当前字符是数字字符
        if (exps[i] >= '0' && exps[i] <= '9') {
            // 1.1.1 则将该数字压入栈中，注意数字字符要转换成数字才能存入栈中，而数字字符要转换成数字可以用数字字符减去'0'字符即可得到所对应的数字
            push(&stack, exps[i] - '0');
        }
        // 1.2 如果当字符不是数字字符，而是运算符
        else {
            // 1.2.1 那么弹出栈顶两个数字，用 a 和 b 来保存
            int a, b;
            pop(&stack, &a);
            pop(&stack, &b);
            // 1.2.2 根据运算符调用函数计算 a 和 b 的结果
            int result = evaluate(exps[i], a, b);
            // 1.2.3 将计算结果压入栈中
            push(&stack, result);
        }
    }

    // 2.最终结果也是存在栈中的，就算栈顶元素，所以获得栈顶元素返回即可
    int top;
    getTop(stack, &top);
    return top;
}

int main() {
    char prefixExp[] = "34+5*6-";
    int n = 7;

    int result;
    result = evaluateSuffixExpression(prefixExp, n);
    printf("后缀表达式计算结果：%d", result);
}

中缀表达式转后缀表达式

算法思想

算法思想如下：

  • 设置一个运算符栈，从左到右扫描中缀表达式中的每个字符：
    • 如果遇到操作数字符（如 1、2等数字），则直接输出操作数到后缀表达式中（有些算法中是用一个栈来存储这些操作数，也是可行的）。
    • 如果遇到非操作数字符，进行如下判断：
      • 如果遇到左括号（如 (），则直接将左括号入栈。
      • 如果遇到右括号（如 )），则执行出栈操作，并将出栈的元素输出到后缀表达式中，直到弹出栈的是左括号为止，注意左括号不输出到后缀表达式中。
      • 如果遇到其他字符（如+、-、*、/等运算符），也需要判断操作：
        • 如果运算符栈为空，则将该运算符直接入栈。
        • 如果运算符栈不为空：
          • 如果栈顶元素是左括号，则直接入栈。
          • 如果栈顶元素是运算符，则需要进行比较：
            • 如果当前扫描到的运算符优先级大于栈顶运算符的优先级，则将当前运算符入栈。
            • 如果当前扫描到的运算符优先级小于等于栈顶运算符，则将栈顶运算符弹出并且输出到后缀表达式中，然后比较新的栈顶运算符，直到当前扫描到的运算符优先级大于栈顶运算符或栈为空为止。再将当前扫描到的运算符入栈。
  • 当从左到右扫描完整个中缀表达式后，检测运算符栈，如果非空，则依次弹栈，将弹出的运算符依次压入到后缀表达式中，最终得到中缀表达式所对应的后缀表达式。

示例

  • 如 1+2*3+(4*5+6)*7 转换后的后缀表达式是 123*+45*6+7*+。
  • 如 (1+2+3*4)/5 转换后的后缀表达式是 12+34*+5/。
  • 如 1+2 转换后的后缀表达式是 12+。
  • 如 (1+2)*3 转换后的后缀表达式是 12+3*。
  • 如 1+2*3 转换后的后缀表达式是 123*+。
  • 如 (6+3*(7-4))-8/2 转换后的后缀表达式是 6374-*+82/-。

例如，有中缀表达式：a+b*c+(d*e+f)*g。转换步骤如下：

  • （1）首先读到操作数 a，直接输出到后缀表达式。
  • （2）接着读到运算符 +，将其入栈。
  • （3）继续读到操作数 b，直接输出到后缀表达式。此时运算符栈和后缀表达式的情况如下：

在这里插入图片描述

  • （4）继续读到运算符 *，因为栈顶元素 + 的优先级比 * 低，所以将 * 直接入栈。
  • （5）继续读到操作数 c，直接输出到后缀表达式。此运算符栈和后缀表达式的情况如下：

在这里插入图片描述

  • （6）继续读到运算符 +，因为栈顶元素 * 的优先级比 + 高，所以弹出 * 并输出到后缀表达式；同理，弹出后现栈顶元素 + 的优先级与读到的运算符 + 一样，所以也弹出 + 并输出到后缀表达式。然后再将读到的 + 压入栈中。此运算符栈和后缀表达式的情况如下：

在这里插入图片描述

  • （7）继续读到的字符是 (，是左括号，优先级最高，直接放入栈中。
  • （8）继续读到操作数 d，将其直接输出到后缀表达式。此运算符栈和后缀表达式的情况如下：

在这里插入图片描述

  • （9）继续读到 * 字符，由于只有遇到右括号 ) 时，左括号 ( 才会弹出，所以直接将 * 压入栈中。
  • （10）继续读到操作数 e，直接输出到后缀表达式。此运算符栈和后缀表达式的情况如下：

在这里插入图片描述

  • （11）继续读到 + ，因为栈顶元素 * 的优先级比 + 高，所以弹出 * 并输出到后缀表达式，并且将当前读到的 + 压入栈中。
  • （12）继续读到操作数 f，直接输出到后缀表达式。此运算符栈和后缀表达式的情况如下：

在这里插入图片描述

  • （13）接下来读到右括号 )，则直接将栈中元素弹出并输出到后缀表达式中，直到遇到左括号 ( 为止。这里右括号前只有一个操作符 + 被弹出并输出到后缀表达式。此运算符栈和后缀表达式的情况如下：

在这里插入图片描述

  • （14）继续读到 * ，因为栈顶元素 + 的优先级比 * 低，所以将 * 直接入栈。
  • （15）继续读到 g，直接输出到后缀表达式中。此运算符栈和后缀表达式的情况如下：

在这里插入图片描述

  • （16）此时输入数据已经读到末尾了，而运算符栈中还有两个操作符 * 和 +，直接弹出并输出到后缀表达式。此运算符栈和后缀表达式的情况如下：

在这里插入图片描述

实现代码

将中缀表达式转换成后缀表达式核心代码如下：

/**
 * 获取运算符的优先级，其中返回数字越小表示优先级越高
 * 注意，仅显示了部分单目运算符的优先级，主要是括号的优先级比乘除运算符的高，乘除运算符的优先级比加减运算符的高
 * @param c 运算符
 * @return 运算符的优先级别
 */
int priority(char c) {
    switch (c) {
        case '(':
        case ')':
            return 1;
        case '/':
        case '*':
        case '%':
            return 3;
        case '+':
        case '-':
            return 4;
        default:
            return 999;
    }
}

/**
 * 中缀表达式转换成后缀表达式
 * @param exps 中缀表达式字符数组
 * @param n 字符数组实际字符个数
 */
void infixToPostfixExpression(char exps[], int n) {
    // 0.声明顺序栈并初始化栈，因为该算法中要使用到栈
    SeqStack stack;
    init(&stack);

    // 变量，记录栈顶元素的值
    char top;

    // 从左到右扫描中缀表达式
    for (int i = 0; i < n; i++) {
        // 局部变量，即当前扫描到的字符
        char c = exps[i];
        // 如果是操作数
        if (c >= '0' && c <= '9') {
            // 则直接输出
            printf("%c", c);
        }
        // 如果不是操作数
        else {
            // 如果是左括号
            if (c == '(') {
                // 则直接入栈
                push(&stack, c);
            }
            // 如果是右括号
            else if (c == ')') {
                // 在栈不为空的情况下
                while (!isEmpty(stack)) {
                    // 出栈栈顶元素
                    pop(&stack, &top);
                    // 直到遇到左括号为止，但并不输出左括号
                    if (top != '(') {
                        printf("%c", top);
                    } else {
                        break;
                    }
                }
            }
            // 如果是其他字符
            else {
                // 如果栈空
                if (isEmpty(stack)) {
                    // 则入栈当前字符
                    push(&stack, c);
                }
                // 如果栈非空
                else {
                    // 在栈不为空的情况
                    while (!isEmpty(stack)) {
                        // 获取栈顶元素
                        getTop(stack, &top);
                        // 弹出栈中所有优先级大于或等于当前字符的栈顶元素，但左括号例外
                        if (top != '(' && priority(c) >= priority(top)) {
                            printf("%c", top);
                            pop(&stack, &top);
                        } else {
                            break;
                        }
                    }
                    // 无论是否出栈元素，都将当前字符入栈
                    push(&stack, c);
                }
            }
        }
    }

    // 扫描完中缀表达式后，检测运算符栈剩余的字符，全部出栈并输出到后缀表达式中
    while (!isEmpty(stack)) {
        char ele;
        pop(&stack, &ele);
        printf("%c", ele);
    }
}

完整代码如下：

#include <stdio.h>

/**
 * 顺序栈最大存储的元素个数
 */
#define MAXSIZE 100

/**
 * 顺序栈结构体定义
 */
typedef struct {
    /**
     * 数据域，数组，用来存储栈中元素
     */
    char data[MAXSIZE];
    /**
     * 指针域，表示栈顶指针，实际上就是数组下标
     */
    int top;
} SeqStack;

/**
 * 初始化顺序栈，即将栈顶指针指向 -1 表示空栈
 * @param stack 顺序栈
 */
void init(SeqStack *stack) {
    // 设定让栈顶指针指向 -1 表示为栈空
    stack->top = -1;
}

/**
 * 判断顺序栈是否为空
 * @param stack 顺序栈
 * @return 如果顺序栈为空则返回 1，否则返回 0
 */
int isEmpty(SeqStack stack) {
    // 只需要判断栈顶指针是否等于 -1 即可，如果是空栈则返回 1，不是空栈则返回 0
    if (stack.top == -1) {
        return 1;
    } else {
        return 0;
    }
}

/**
 * 将元素入栈
 * @param stack 顺序栈
 * @param ele 元素值
 * @return 如果栈满则返回 0 表示入栈失败；如果插入成功则返回 1
 */
int push(SeqStack *stack, char ele) {
    // 1.参数校验，如果栈满则不能入栈元素
    if (stack->top == MAXSIZE - 1) {
        // 如果栈满，则返回 0，表示不能入栈
        return 0;
    }
    // 2.先将栈顶指针加一，指向新空数组位置
    stack->top++;
    // 3.将新元素值填充到新位置中
    stack->data[stack->top] = ele;
    return 1;
}

/**
 * 将元素出栈
 * @param stack 顺序栈
 * @param ele 用来保存出栈的元素
 * @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
 */
int pop(SeqStack *stack, char *ele) {
    // 1.参数校验，栈空不能出栈
    if (stack->top == -1) {
        // 栈空，没有元素可出栈
        return 0;
    }
    // 2.用 ele 来保存顺序栈栈顶元素
    *ele = stack->data[stack->top];
    // 3.然后栈顶指针减一，表示出栈一个元素
    stack->top--;
    return 1;
}

/**
 * 获取栈顶元素，但不出栈
 * @param stack 顺序栈
 * @param ele 用来保存出栈元素
 * @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
 */
int getTop(SeqStack stack, char *ele) {
    // 1.参数校验，如果栈空则不能出栈
    if (stack.top == -1) {
        // 栈空，没有元素可出栈
        return 0;
    }
    // 2.保存栈顶元素返回
    *ele = stack.data[stack.top];
    return 1;
}

/**
 * 获取运算符的优先级，其中返回数字越小表示优先级越高
 * 注意，仅显示了部分单目运算符的优先级，主要是括号的优先级比乘除运算符的高，乘除运算符的优先级比加减运算符的高
 * @param c 运算符
 * @return 运算符的优先级别
 */
int priority(char c) {
    switch (c) {
        case '(':
        case ')':
            return 1;
        case '/':
        case '*':
        case '%':
            return 3;
        case '+':
        case '-':
            return 4;
        default:
            return 999;
    }
}

/**
 * 中缀表达式转换成后缀表达式
 * @param exps 中缀表达式字符数组
 * @param n 字符数组实际字符个数
 */
void infixToPostfixExpression(char exps[], int n) {
    // 0.声明顺序栈并初始化栈，因为该算法中要使用到栈
    SeqStack stack;
    init(&stack);

    // 变量，记录栈顶元素的值
    char top;

    // 从左到右扫描中缀表达式
    for (int i = 0; i < n; i++) {
        // 局部变量，即当前扫描到的字符
        char c = exps[i];
        // 如果是操作数
        if (c >= '0' && c <= '9') {
            // 则直接输出
            printf("%c", c);
        }
        // 如果不是操作数
        else {
            // 如果是左括号
            if (c == '(') {
                // 则直接入栈
                push(&stack, c);
            }
            // 如果是右括号
            else if (c == ')') {
                // 在栈不为空的情况下
                while (!isEmpty(stack)) {
                    // 出栈栈顶元素
                    pop(&stack, &top);
                    // 直到遇到左括号为止，但并不输出左括号
                    if (top != '(') {
                        printf("%c", top);
                    } else {
                        break;
                    }
                }
            }
            // 如果是其他字符
            else {
                // 如果栈空
                if (isEmpty(stack)) {
                    // 则入栈当前字符
                    push(&stack, c);
                }
                // 如果栈非空
                else {
                    // 在栈不为空的情况
                    while (!isEmpty(stack)) {
                        // 获取栈顶元素
                        getTop(stack, &top);
                        // 弹出栈中所有优先级大于或等于当前字符的栈顶元素，但左括号例外
                        if (top != '(' && priority(c) >= priority(top)) {
                            printf("%c", top);
                            pop(&stack, &top);
                        } else {
                            break;
                        }
                    }
                    // 无论是否出栈元素，都将当前字符入栈
                    push(&stack, c);
                }
            }
        }
    }

    // 扫描完中缀表达式后，检测运算符栈剩余的字符，全部出栈并输出到后缀表达式中
    while (!isEmpty(stack)) {
        char ele;
        pop(&stack, &ele);
        printf("%c", ele);
    }
}

int main() {
    char infixExp[] = "1+2*3+(4*5+6)*7";
    int n =15;

    infixToPostfixExpression(infixExp, n);
}

其他转换方式

将中缀表达式转换成后缀表达式的另外一种方法（适合选择题快速计算后缀表达式）：

  • 例如，有中缀表达式 a+b*c+(d*e+f)*g。
  • 先按照运算符的优先级对中缀表达式加括号，变成：((a+(b*c))+(((d*e)+f)*g))。
  • 接着将运算符移到括号的后面，变成：((a(bc)*)+(((de)*f)+g)*)+。
  • 最后去掉括号得到后缀表达式：abc*+de*f+g*+。

中缀表达式转前缀表达式

算法思想

算法思想：

  • 设定一个运算符栈，从右往左顺序扫描整个中缀表达式中的每个字符：
    • 如果遇到的是操作数字符（如 1、2等数字），则直接输出到前缀表达式。
    • 如果遇到的是非操作数字符，进行如下判断：
      • 如果遇到右括号（如 )），则直接将其入栈。
      • 如果遇到左括号（如 (），则直接出栈操作，并将出栈的元素输出到前缀表达式中，直到弹出栈的是右括号为止，注意右括号不输出到前缀表达式中。
      • 如果遇到其他字符（如 +、-、*、-等运算符），也需要判断：
        • 如果运算符栈为空，则将该运算符直接入栈。
        • 如果运算符栈不为空，则：
          • 如果栈顶元素是右括号，则直接入栈。
          • 如果栈顶元素是运算符，则需要进行比较：
            • 如果当前扫描到的运算符优先级大于等于栈顶运算符，则直接入栈。
            • 如果当前扫描到的运算符优先级小于栈顶运算符，则将栈顶运算符弹出并且输出到前缀表达式，然后比较新的栈顶运算符，直到当前运算符的优先级大于等于栈顶运算符或栈为空为止。再将当前运算符入栈。
  • 当扫描完毕整个中缀表达式，检测运算符栈是否为空，如果不为空，则依次将栈中运算符弹出栈，并且输出到前缀表达式。
  • 最后将前缀表达式翻转，得到中缀表达式对应的前缀表达式。

示例

  • 如 1+2*3+(4*5+6)*7 转换后的前缀表达式是 ++1*23*+*4567。
  • 如 1+(2+3)*4-5 转换后的前缀表达式是 -+1*+2345。

有中缀表达式 a+b*c+(d*e+f)*g，转换步骤如下：

  • （1）首先读到操作数 g，直接输出到前缀表达式。
  • （2）继续读到 *，将其放入运算符栈中。
  • （3）继续读到 )，因为栈顶元素 * 的优先级比 ) 低，所以将 ) 直接压入栈中。此时运算符栈和前缀表达式如下：

在这里插入图片描述

  • （4）继续读到操作数 f，直接输出到前缀表达式。
  • （5）继续读到 +，直接入栈。
  • （6）继续读到操作数 e，直接输出到前缀表达式。此时运算符栈和前缀表达式如下：

在这里插入图片描述

  • （7）继续读到 *，因为栈顶元素是 + 的优先级比 * 低，所以直接将 * 入栈。
  • （8）继续读到操作数 d，直接输出道前缀表达式。此时运算符栈和前缀表达式如下：

在这里插入图片描述

  • （9）继续读到 (，将栈中的操作符依次弹出栈，直到遇到 )。此时运算符栈和前缀表达式如下：

在这里插入图片描述

  • （10）继续读到 +，因为栈顶元素 * 的优先级比 + 高，因此弹出栈顶元素并输出道前缀表达式，再将 + 入栈。此时运算符栈和前缀表达式如下：

在这里插入图片描述

  • （11）继续读到操作数 c，直接输出到前缀表达式。
  • （12）继续读到 *，因为栈顶元素 + 优先级比 *，所以直接将 * 入栈。
  • （13）继续读到 b，直接输出到前缀表达式。此时运算符栈和前缀表达式如下：

在这里插入图片描述

  • （14）继续读到 +，因为栈顶元素 * 的优先级比 + 高，所以弹出栈顶元素并输出到前缀表达式中，然后再将 + 入栈。
  • （15）继续读到 a，直接输出到前缀表达式。此时运算符栈和前缀表达式如下：

在这里插入图片描述

  • （16）此时输入数据已经读到末尾，栈中还有两个操作符 + 和 +，直接弹出并输出到前缀表达式。此时运算符栈和前缀表达式如下：

在这里插入图片描述

  • （17）将前缀表达式翻转，得到中缀表达式对应的真正前缀表达式。

在这里插入图片描述

实现代码

将中缀表达式转换成前缀表达式核心代码如下：

/**
 * 获取运算符的优先级，其中返回数字越小表示优先级越高
 * 注意，仅显示了部分单目运算符的优先级，主要是括号的优先级比乘除运算符的高，乘除运算符的优先级比加减运算符的高
 * @param c 运算符
 * @return 运算符的优先级别
 */
int priority(char c) {
    switch (c) {
        case '(':
        case ')':
            return 1;
        case '/':
        case '*':
        case '%':
            return 3;
        case '+':
        case '-':
            return 4;
        default:
            return 999;
    }
}

/**
 * 中缀表达式转换成前缀表达式
 * @param exps 中缀表达式字符数组
 * @param n 字符数组实际字符个数
 */
SeqStack infixToPrefixExpression(char exps[], int n) {
    // 0.声明顺序栈并初始化栈，因为该算法中要使用到栈
    SeqStack stack;
    init(&stack);
    // 1.因为最后要将前缀表达式翻转，所以再创建一个栈用来存储转换后的前缀表达式，最后打印栈就直接是翻转后的前缀表达式了
    SeqStack resultStack;
    init(&resultStack);

    // 变量，记录栈顶元素的值
    char top;

    // 从右到左扫描中缀表达式
    for (int i = n - 1; i >= 0; i--) {
        // 局部变量，即当前扫描到的字符
        char c = exps[i];
        // 如果是操作数
        if (c >= '0' && c <= '9') {
            // 则直接输出，这里是存储到结果栈中
            push(&resultStack, c);
        }
        // 如果不是操作数
        else {
            // 如果是右括号
            if (c == ')') {
                // 则直接入栈
                push(&stack, c);
            }
            // 如果是左括号
            else if (c == '(') {
                // 在栈不为空的情况下
                while (!isEmpty(stack)) {
                    // 出栈栈顶元素
                    pop(&stack, &top);
                    // 直到遇到右括号为止，但并不输出右括号
                    if (top != ')') {
                        // 则直接输出，这里是存储到结果栈中
                        push(&resultStack, top);
                    } else {
                        break;
                    }
                }
            }
            // 如果是其他字符
            else {
                // 如果栈空
                if (isEmpty(stack)) {
                    // 则入栈当前字符
                    push(&stack, c);
                }
                // 如果栈非空
                else {
                    // 获取栈顶元素
                    getTop(stack, &top);
                    if(top==')'){
                        push(&stack, c);
                    } else{
                        // 注意，数字越小优先级越高
                        if(priority(c)<= priority(top)){
                            push(&stack, c);
                        } else{
                            // 在栈不为空的情况
                            while (!isEmpty(stack)) {
                                // 获取栈顶元素
                                getTop(stack, &top);
                                // 弹出栈中所有优先级大于当前字符的栈顶元素
                                if (priority(c) > priority(top)) {
                                    // 则直接输出，这里是存储到结果栈中
                                    push(&resultStack, top);
                                    // 将运算符栈栈顶元素出栈
                                    pop(&stack, &top);
                                } else {
                                    break;
                                }
                            }
                            // 无论是否出栈元素，都将当前字符入栈
                            push(&stack, c);
                        }
                    }
                }
            }
        }
    }

    // 扫描完中缀表达式后，检测运算符栈剩余的字符，全部出栈并输出到前缀表达式中
    while (!isEmpty(stack)) {
        char ele;
        pop(&stack, &ele);
        // 则直接输出，这里是存储到结果栈中
        push(&resultStack, ele);
    }

    // 返回结果栈
    return resultStack;
}

完整代码如下：

#include <stdio.h>

/**
 * 顺序栈最大存储的元素个数
 */
#define MAXSIZE 100

/**
 * 顺序栈结构体定义
 */
typedef struct {
    /**
     * 数据域，数组，用来存储栈中元素
     */
    char data[MAXSIZE];
    /**
     * 指针域，表示栈顶指针，实际上就是数组下标
     */
    int top;
} SeqStack;

/**
 * 初始化顺序栈，即将栈顶指针指向 -1 表示空栈
 * @param stack 顺序栈
 */
void init(SeqStack *stack) {
    // 设定让栈顶指针指向 -1 表示为栈空
    stack->top = -1;
}

/**
 * 判断顺序栈是否为空
 * @param stack 顺序栈
 * @return 如果顺序栈为空则返回 1，否则返回 0
 */
int isEmpty(SeqStack stack) {
    // 只需要判断栈顶指针是否等于 -1 即可，如果是空栈则返回 1，不是空栈则返回 0
    if (stack.top == -1) {
        return 1;
    } else {
        return 0;
    }
}

/**
 * 将元素入栈
 * @param stack 顺序栈
 * @param ele 元素值
 * @return 如果栈满则返回 0 表示入栈失败；如果插入成功则返回 1
 */
int push(SeqStack *stack, char ele) {
    // 1.参数校验，如果栈满则不能入栈元素
    if (stack->top == MAXSIZE - 1) {
        // 如果栈满，则返回 0，表示不能入栈
        return 0;
    }
    // 2.先将栈顶指针加一，指向新空数组位置
    stack->top++;
    // 3.将新元素值填充到新位置中
    stack->data[stack->top] = ele;
    return 1;
}

/**
 * 将元素出栈
 * @param stack 顺序栈
 * @param ele 用来保存出栈的元素
 * @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
 */
int pop(SeqStack *stack, char *ele) {
    // 1.参数校验，栈空不能出栈
    if (stack->top == -1) {
        // 栈空，没有元素可出栈
        return 0;
    }
    // 2.用 ele 来保存顺序栈栈顶元素
    *ele = stack->data[stack->top];
    // 3.然后栈顶指针减一，表示出栈一个元素
    stack->top--;
    return 1;
}

/**
 * 获取栈顶元素，但不出栈
 * @param stack 顺序栈
 * @param ele 用来保存出栈元素
 * @return 如果栈空则返回 0 表示出栈失败；否则返回 1 表示出栈成功
 */
int getTop(SeqStack stack, char *ele) {
    // 1.参数校验，如果栈空则不能出栈
    if (stack.top == -1) {
        // 栈空，没有元素可出栈
        return 0;
    }
    // 2.保存栈顶元素返回
    *ele = stack.data[stack.top];
    return 1;
}

/**
 * 获取运算符的优先级，其中返回数字越小表示优先级越高
 * 注意，仅显示了部分单目运算符的优先级，主要是括号的优先级比乘除运算符的高，乘除运算符的优先级比加减运算符的高
 * @param c 运算符
 * @return 运算符的优先级别
 */
int priority(char c) {
    switch (c) {
        case '(':
        case ')':
            return 1;
        case '/':
        case '*':
        case '%':
            return 3;
        case '+':
        case '-':
            return 4;
        default:
            return 999;
    }
}

/**
 * 中缀表达式转换成前缀表达式
 * @param exps 中缀表达式字符数组
 * @param n 字符数组实际字符个数
 */
SeqStack infixToPrefixExpression(char exps[], int n) {
    // 0.声明顺序栈并初始化栈，因为该算法中要使用到栈
    SeqStack stack;
    init(&stack);
    // 1.因为最后要将前缀表达式翻转，所以再创建一个栈用来存储转换后的前缀表达式，最后打印栈就直接是翻转后的前缀表达式了
    SeqStack resultStack;
    init(&resultStack);

    // 变量，记录栈顶元素的值
    char top;

    // 从右到左扫描中缀表达式
    for (int i = n - 1; i >= 0; i--) {
        // 局部变量，即当前扫描到的字符
        char c = exps[i];
        // 如果是操作数
        if (c >= '0' && c <= '9') {
            // 则直接输出，这里是存储到结果栈中
            push(&resultStack, c);
        }
        // 如果不是操作数
        else {
            // 如果是右括号
            if (c == ')') {
                // 则直接入栈
                push(&stack, c);
            }
            // 如果是左括号
            else if (c == '(') {
                // 在栈不为空的情况下
                while (!isEmpty(stack)) {
                    // 出栈栈顶元素
                    pop(&stack, &top);
                    // 直到遇到右括号为止，但并不输出右括号
                    if (top != ')') {
                        // 则直接输出，这里是存储到结果栈中
                        push(&resultStack, top);
                    } else {
                        break;
                    }
                }
            }
            // 如果是其他字符
            else {
                // 如果栈空
                if (isEmpty(stack)) {
                    // 则入栈当前字符
                    push(&stack, c);
                }
                // 如果栈非空
                else {
                    // 获取栈顶元素
                    getTop(stack, &top);
                    if(top==')'){
                        push(&stack, c);
                    } else{
                        // 注意，数字越小优先级越高
                        if(priority(c)<= priority(top)){
                            push(&stack, c);
                        } else{
                            // 在栈不为空的情况
                            while (!isEmpty(stack)) {
                                // 获取栈顶元素
                                getTop(stack, &top);
                                // 弹出栈中所有优先级大于当前字符的栈顶元素
                                if (priority(c) > priority(top)) {
                                    // 则直接输出，这里是存储到结果栈中
                                    push(&resultStack, top);
                                    // 将运算符栈栈顶元素出栈
                                    pop(&stack, &top);
                                } else {
                                    break;
                                }
                            }
                            // 无论是否出栈元素，都将当前字符入栈
                            push(&stack, c);
                        }
                    }
                }
            }
        }
    }

    // 扫描完中缀表达式后，检测运算符栈剩余的字符，全部出栈并输出到前缀表达式中
    while (!isEmpty(stack)) {
        char ele;
        pop(&stack, &ele);
        // 则直接输出，这里是存储到结果栈中
        push(&resultStack, ele);
    }

    // 返回结果栈
    return resultStack;
}

int main() {
    char infixExp[] = "1+2*3+(4*5+6)*7";
    int n = 15;

    // 调用函数将中缀表达式转换成前缀表达式
    SeqStack resultStack = infixToPrefixExpression(infixExp, n);
    // 最后打印结果栈，从栈顶到栈底，就直接是前缀表达式翻转后的结果
    while (!isEmpty(resultStack)) {
        char ele;
        pop(&resultStack, &ele);
        printf("%c", ele);
    }
}

其他转换方式

还可以通过另外一种方式将中缀表达式转换成前缀表达式（适合选择题快速计算前缀表达式）：

  • 例如，有中缀表达式 a+b*c+(d*e+f)*g。
  • 先按照运算符的优先级对中缀表达式加括号，变成：((a+(b*c))+(((d*e)+f)*g))。
  • 接着将运算符移到括号的前面，变成：+(+(a*(bc))*(+(*(de)f)g))。
  • 最后去掉括号得到前缀表达式：++a*bc*+*defg。
二木成林
关注
专栏目录
前缀、中缀、后缀表达式
Antineutrino的专栏
09-09 18万+
关键字：概念, 前缀表达式, 前缀记法, 中缀表达式, 中缀记法, 波兰式, 后缀表达式, 后缀记法, 逆波兰式 它们都是对表达式的记法，因此也被称为前缀记法、中缀记法和后缀记法。它们之间的区别在于运算符相对与操作数的位置不同：前缀表达式的运算符位于与其相关的操作数之前
中缀表达式转前缀表达式java实现
qq_34092585的博客
06-25 5430
中缀表达式转前缀表达式java实现 准备知识： 前缀、中缀、后缀表达式 http://note.youdao.com/noteshare?id=c27a0ee6222c18ec60cf5bb2154b0744&sub=4CEC6E1E196B4B228839B9220F9F673C 前缀、中缀、后缀表达式和二叉树的关系 http://note.youdao.com/noteshare?id...
前缀表达式、中缀表达式和后缀表达式 - 乘月归 - 博客园.pdf
03-15
转
前缀、中缀、后缀表达式(逆波兰表达式)
chen-sx
12-12 1803
前缀、中缀、后缀表达式(逆波兰表达式) 介绍 前缀表达式、中缀表达式、后缀表达式都是四则运算的表达方式,用以四则运算表达式求值 ,即数学表达式的求职 中缀表达式 简介 中缀表达式就是常见的运算表达式，如(3+4)×5-6 前缀表达式 简介 前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前 比如:- × + 3 4 5 6
前缀表达式,中缀表达式,后缀表达式
05-04 935
(1)表达式的三种形式： 中缀表达式：运算符放在两个运算对象中间，如：(2+1)*3； 后缀表达式：不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则，如：2 1 + 3 *； 前缀表达式：同后缀表达式一样，不包含括号，运算符放在两个运算对象的前面，如：* + 2 1 3。 (2)表达式的计算： 由于后缀表达式中没有括号，不需判别优先
前缀表达式、中缀表达式、后缀表达式
最新发布
逐梦苍穹的博客
05-30 4761
本文介绍三种表达式（前缀表达式、中缀表达式和后缀表达式）
python中缀表达式_中缀表达式变后缀表达式、后缀表达式（逆波兰）求值(python版本)...
weixin_39737051的博客
12-09 1281
定义: 中缀表达式:在通常的表达式中,二元运算符总是置于与之相关的两个运算对象之间,这种表示法也称为中缀表达式 后缀表达式: 又叫逆波兰表达式 ,不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则,如:(2 + 1) * 3 , 即2 1 + 3 * 一个字符串表达式s = “9 + ( 3 - 1 ) * 3 + 10 / 2”)...
C#学习之逆波兰公式简单实现
青子的专栏
05-12 1919
Stack和Stack Stack和Stack则是后进先出的数据结构，通过Push和Pop法实现添加元素到队列的顶部和从队列的顶部移除元素。同样也提供了Peek方法、Count属性和ToArray方法。 栈的实践使用：逆波兰公式 表达式一般由操作数(Operand)、运算符(Operator)组成，例如算术表达式中，通常把运算符放在两个操作数的中间， 这称为中缀表达式(Infix
YACC实验报告
weixin_42427149的博客
11-09 1808
程序设计 2 语法分析程序的设计与实现 （一）实验内容 编写语法分析程序，实现对算数表达式的语法分析。要求所分析算数表达式由如下的文法产生。 E→E+T∣E−T∣T E \rightarrow E + T \mid E - T \mid T E→E+T∣E−T∣T T→T∗F∣T/F∣F T \rightarrow T * F \mid T / F \mid F T→T∗F∣T/F∣F F→(E)...
Leetcode Solutions - Part 2
vjhghjghj的博客
02-25 1749
m
前缀表达式、中缀表达式、后缀表达式。
Leibnezz的博客
12-22 473
表达式 表达式：就是式子。是由数字、算符、数字分组符号、自由量和约束量组成的。人们一般习惯写出来的式子，叫做中缀表达式。 因为在计算机中，不方便表达 数字分组符号。所以 波兰人发明了一种把去符号化的表达式。前缀表达式 前缀表达式 前缀表达式：没有括号，算符在前 数字在后。波兰数学家发明，为了纪念，又叫做波兰式。 跟其对应，有一后缀表达式。 后缀表达式 后缀表达式：没有括号，数字在前，算符在后。...
前缀表达式/中缀表达式/后缀表达式
一叶的博客
03-02 3813
前缀表达式/中缀表达式/后缀表达式 中缀表达式就是平常的表达式，如(3+4)*5-6=29 前缀表达式又称为波兰式，也就是运算符位于数字前面，如 -*+3456 后缀表达式又称为逆波兰式，也就是运算符位于数字后面，如 3 4 + 5 × 6 - 后缀表达式转中缀表达式，ab+cd+* 后缀表达式转为中缀表达式要点：遇到操作数都进栈，等到碰到运算符就把栈顶两个元素出栈，运算后再入栈，直到结束...
前缀表达式 | 中缀表达式 | 后缀表达式
我是菜鸡
03-18 818
　　看题目有点深奥的样子，然而弄明白之后也就那么回事。 (´-ι_-｀)虽然我刚开始根本没弄懂…… 中缀表达式 　　中缀表达式（或中缀记法）是一个通用的算术或逻辑公式表示方法， 操作符是以中缀形式处于操作数的中间。其实说白了，我们平时写的式子都是中缀表达式，就是说运算符位于要计算的两个数中间。中缀表达式不容易被计算机解析，但仍被许多程序语言使用，因为它符合人们的普遍用法。 前缀表达式和后缀表...
数据结构与算法(8):前缀表达式(波兰表达式),中缀表达式,后缀表达式(逆波兰表达式:实例逆波兰计算器)
qq_42400763的博客
09-14 1084
一:前缀表达式的计算机求值   从右到左扫描表达式,遇到了数字,就将数字压入堆栈,遇到运算符就将运算符压入堆栈,弹出栈顶的两个数,用运算符对他们做相应的计算.(栈顶元素,和次顶元素).并将结果入栈,接着重复上述的过程指导表达式的最左端,最后运算得出的值即为表达式的结果 举个例子:(3+4)*5-6对应的前缀表达式就是-*+3456,针对前缀表达式求值步骤如下: 从右到左进行扫描,将6543依次压入栈中 遇到+运算符后弹出3和4(3为栈顶一个元素,4为次顶元素),计算出3+4的值后,得到的7压入栈中. 接下
前缀、中缀、后缀表达式及其求值
aibaiwu6038的博客
02-26 519
它们都是对表达式的记法，因此也被称为前缀记法、中缀记法和后缀记法。它们之间的区别在于运算符相对与操作数的位置不同：前缀表达式的运算符位于与其相关的操作数之前；中缀和后缀同理。 比如： (4 + 5) × 6- 7 就是中缀表达式 - × + 4567 前缀表达式 45 + 6×7 - 后缀表达式 中缀表达式（中缀记法） 中缀表达式是一种通用的算术或逻辑公式表示方法，操作...
Java实现：前缀-中缀-后缀表达式转换及求值详解
总结来说，本篇文章涵盖了前缀、中缀和后缀表达式的概念、特点、求值方法以及它们在计算机编程中的实际应用，特别是如何通过数据结构（如栈）来实现高效的算法。这对于理解和处理复杂的数学计算问题，尤其是在Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值