中缀表达式转后缀表达式c++

中缀表达式转后缀表达式，是一种运算符写在操作数之后的表达式表示方法。下面是一个将中缀表达式转换为后缀表达式的算法：
1. 创建一个栈（称为运算符栈）和一个空字符串（用于存储后缀表达式）。
2. 从左到右扫描中缀表达式的每个元素。
3. 如果遇到操作数（即数字），则将其直接附加到后缀表达式的末尾。
4. 如果遇到操作符，检查运算符栈的栈顶元素：
a. 如果运算符栈为空，或者栈顶元素是左括号"("，则将该操作符入栈。
b. 如果当前的操作符比运算符栈的栈顶元素优先级高，则将该操作符入栈。
c. 如果当前的操作符比运算符栈的栈顶元素优先级低或相等，则将运算符栈的栈顶元素弹出并附加到后缀表达式的末尾，直到当前的操作符的优先级高于栈顶元素。
5. 如果遇到左括号"("，则将其入栈。
6. 如果遇到右括号")"，则弹出运算符栈的元素并附加到后缀表达式的末尾，直到弹出一个左括号"("。
7. 将中缀表达式扫描完毕后，如果运算符栈不为空，则将栈中的所有元素依次弹出并附加到后缀表达式的末尾。

例如，对于中缀表达式"c = a + b * ( d * e + f ) - g"，根据上述算法转换为后缀表达式为："c a b d e * f + * + g -"。

注意：以上算法没有考虑操作符的结合性，如果需要添加结合性的支持，还需对算法进行适当修改。

相关问题

中缀表达式转后缀表达式 c++

中缀表达式是指操作符在操作数的中间，而后缀表达式是指操作符在操作数的后面。要将中缀表达式转换为后缀表达式，可以使用栈来辅助转换。

首先，我们需要遍历中缀表达式的每个字符。如果是操作数，则直接输出到后缀表达式中；如果是操作符，则需要判断其优先级和栈顶操作符的优先级来确定输出顺序。

具体步骤如下：
1. 创建一个空栈用于存放操作符；
2. 从左到右遍历中缀表达式的每个字符；
3. 如果是操作数，则直接加入后缀表达式；
4. 如果是操作符，需要判断其与栈顶操作符的优先级，如果栈顶操作符的优先级大于等于当前操作符，则将栈顶操作符弹出加入后缀表达式，并继续比较下一个栈顶操作符的优先级直到小于当前操作符，然后将当前操作符入栈；
5. 如果遍历完中缀表达式后，栈中仍有操作符，则依次将栈中操作符加入后缀表达式；

经过以上步骤，就可以将中缀表达式转换为后缀表达式了。

举例：
中缀表达式：a + b * c - (d / e + f) * g
后缀表达式：a b c * + d e / f + g * -

中缀表达式转后缀表达式c++代码

我可以回答您的问题，以下是将中缀表达式转换为后缀表达式的C代码示例：

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

#define SIZE 100

char stack[SIZE];
int top = -1;

void push(char item) {
    if (top >= SIZE - 1) {
        printf("\nStack Overflow.");
    }
    else {
        top = top + 1;
        stack[top] = item;
    }
}

char pop() {
    char item;

    if (top < 0) {
        printf("stack under flow: invalid infix expression");
        getchar();
        exit(1);
    }
    else {
        item = stack[top];
        top = top - 1;
        return (item);
    }
}

int is_operator(char symbol) {
    if (symbol == '^' || symbol == '*' || symbol == '/' || symbol == '+' || symbol == '-') {
        return 1;
    }
    else {
        return 0;
    }
}

int precedence(char symbol) {
    if (symbol == '^') {
        return (3);
    }
    else if (symbol == '*' || symbol == '/') {
        return (2);
    }
    else if (symbol == '+' || symbol == '-') {
        return (1);
    }
    else {
        return (0);
    }
}

void infix_to_postfix(char infix_exp[], char postfix_exp[]) {
    int i, j;
    char item;
    char x;

    push('(');
    strcat(infix_exp, ")");
    i = 0;
    j = 0;
    item = infix_exp[i];

    while (item != '\0') {
        if (item == '(') {
            push(item);
        }
        else if (isdigit(item) || isalpha(item)) {
            postfix_exp[j] = item;
            j++;
        }
        else if (is_operator(item) == 1) {
            x = pop();
            while (is_operator(x) == 1 && precedence(x) >= precedence(item)) {
                postfix_exp[j] = x;
                j++;
                x = pop();
            }
            push(x);
            push(item);
        }
        else if (item == ')') {
            x = pop();
            while (x != '(') {
                postfix_exp[j] = x;
                j++;
                x = pop();
            }
        }
        else {
            printf("\nInvalid infix Expression.\n");
            getchar();
            exit(1);
        }
        i++;

        item = infix_exp[i];
    }
    if (top > 0) {
        printf("\nInvalid infix Expression.\n");
        getchar();
        exit(1);
    }
    postfix_exp[j] = '\0';
}

int main() {
    char infix[SIZE], postfix[SIZE];

    printf("Enter Infix expression : ");
    gets_s(infix);

    infix_to_postfix(infix, postfix);
    printf("Postfix Expression: ");
    puts(postfix);

    return 0;
}

希望这能帮助您。