C语言编写代码1、[问题描述]输入一个中缀表达式，将其转换为后缀表达式，然后对后缀表达式进行求值。运算符包括“+”、“-”、“*”“/”、“(”“) ”、“#”，参加运算的数为小于 10 的自然数。 2、[输入要求]多组数据，每组数据一行，对应一个算术表达式，每个表达式均 以“#”结尾。当表达式只有一个“#”时，输入结束。 3、[输出要求]对于每组数据输出 2 行，第一行为中缀表达式对应的后缀式，第2行为后缀求值的运算结果。

以下是C语言代码实现：

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

#define MAXLEN 100 // 定义字符串最大长度
#define ERROR -1 // 定义错误返回值

typedef struct stack {
    char data[MAXLEN]; // 栈的数据域
    int top; // 栈顶指针
} Stack;

// 初始化栈
void init(Stack *s) {
    s->top = -1;
}

// 判断栈是否为空
int isEmpty(Stack *s) {
    return s->top == -1;
}

// 判断栈是否已满
int isFull(Stack *s) {
    return s->top == MAXLEN - 1;
}

// 入栈
void push(Stack *s, char c) {
    if (isFull(s)) {
        printf("Stack overflow!\n");
        exit(ERROR);
    }
    s->data[++s->top] = c;
}

// 出栈
char pop(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack underflow!\n");
        exit(ERROR);
    }
    return s->data[s->top--];
}

// 获取栈顶元素
char getTop(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack is empty!\n");
        exit(ERROR);
    }
    return s->data[s->top];
}

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

// 中缀表达式转后缀表达式
void infixToPostfix(char *infix, char *postfix) {
    Stack s;
    init(&s);
    int i = 0, j = 0;
    push(&s, '#');
    while (infix[i] != '#' || getTop(&s) != '#') {
        if (isdigit(infix[i])) {
            postfix[j++] = infix[i++];
        } else if (infix[i] == '(') {
            push(&s, '(');
            i++;
        } else if (infix[i] == ')') {
            while (getTop(&s) != '(') {
                postfix[j++] = pop(&s);
            }
            pop(&s);
            i++;
        } else {
            while (getPriority(infix[i]) <= getPriority(getTop(&s))) {
                postfix[j++] = pop(&s);
            }
            push(&s, infix[i++]);
        }
    }
    postfix[j] = '\0';
}

// 计算后缀表达式的值
int postfixEval(char *postfix) {
    Stack s;
    init(&s);
    int i = 0;
    while (postfix[i] != '\0') {
        if (isdigit(postfix[i])) {
            push(&s, postfix[i] - '0');
            i++;
        } else {
            int op1 = pop(&s);
            int op2 = pop(&s);
            int result;
            switch (postfix[i]) {
                case '+':
                    result = op2 + op1;
                    break;
                case '-':
                    result = op2 - op1;
                    break;
                case '*':
                    result = op2 * op1;
                    break;
                case '/':
                    result = op2 / op1;
                    break;
                default:
                    printf("Invalid operator!\n");
                    exit(ERROR);
            }
            push(&s, result);
            i++;
        }
    }
    return pop(&s);
}

int main() {
    char infix[MAXLEN], postfix[MAXLEN];
    while (1) {
        printf("Please input an infix expression (end with #):\n");
        scanf("%s", infix);
        if (infix[0] == '#' && infix[1] == '\0') {
            break;
        }
        infixToPostfix(infix, postfix);
        printf("Postfix expression: %s\n", postfix);
        printf("Result: %d\n", postfixEval(postfix));
    }
    return 0;
}

代码思路：

1. 定义栈结构体，包括数据域和栈顶指针。
2. 初始化栈，判断栈是否为空或已满，实现入栈、出栈和获取栈顶元素等操作。
3. 定义函数获取运算符的优先级。
4. 实现中缀表达式转后缀表达式的函数，利用栈来存储运算符，遍历中缀表达式的每个字符，如果是数字则直接输出到后缀表达式中，如果是左括号则入栈，如果是右括号则将栈中的运算符依次弹出并输出到后缀表达式中，直到遇到左括号为止，最后将左括号从栈中弹出，如果是运算符则比较其与栈顶运算符的优先级，如果优先级低于等于栈顶运算符，则将栈顶运算符弹出并输出到后缀表达式中，直到栈为空或栈顶运算符优先级低于当前运算符，最后将当前运算符入栈。
5. 实现计算后缀表达式的函数，遍历后缀表达式的每个字符，如果是数字则入栈，如果是运算符则弹出栈顶的两个数字进行运算，将结果入栈，最后栈中只剩下一个数字，即为表达式的值。
6. 主函数中循环读入中缀表达式，如果输入的是一个单独的“#”，则退出循环，否则输出转换后的后缀表达式和计算结果。