用c语言实现中缀表达式求值

由于中缀表达式的计算涉及到运算符的优先级和括号的影响，因此需要使用栈来辅助计算。具体步骤如下：

1. 定义一个栈来存储运算符和操作数。
2. 从左到右扫描中缀表达式，如果当前字符为数字，则将其入栈。
3. 如果当前字符为运算符，则判断其与栈顶运算符的优先级，如果当前运算符优先级小于等于栈顶运算符优先级，则将栈顶运算符弹出并进行运算，将运算结果入栈，重新比较当前运算符与栈顶运算符的优先级。如果当前运算符优先级大于栈顶运算符优先级，则直接入栈。
4. 如果当前字符为左括号，直接入栈。
5. 如果当前字符为右括号，则依次弹出栈顶运算符并进行运算，直到遇到左括号为止，左括号出栈但不入栈。
6. 最后，依次弹出栈顶运算符并进行运算，直到栈为空，得出最终结果。

下面是用C语言实现中缀表达式求值的代码：

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

#define MAX_SIZE 100

typedef struct {
    int top;
    int data[MAX_SIZE];
} Stack;

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

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

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

// 入栈
void push(Stack *s, int val) {
    if (is_full(s)) {
        printf("Stack overflow\n");
        exit(1);
    }
    s->data[++s->top] = val;
}

// 出栈
int pop(Stack *s) {
    if (is_empty(s)) {
        printf("Stack underflow\n");
        exit(1);
    }
    return s->data[s->top--];
}

// 获取栈顶元素
int peek(Stack *s) {
    if (is_empty(s)) {
        printf("Stack underflow\n");
        exit(1);
    }
    return s->data[s->top];
}

// 判断是否为运算符
int is_operator(char ch) {
    return ch == '+' || ch == '-' || ch == '*' || ch == '/';
}

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

// 计算表达式
int evaluate(char *expr) {
    Stack op_stack, val_stack;
    init(&op_stack);
    init(&val_stack);
    int i, len, val, val1, val2;
    char ch, op;
    len = strlen(expr);
    for (i = 0; i < len; i++) {
        ch = expr[i];
        if (isdigit(ch)) {
            val = ch - '0';
            while (isdigit(expr[i+1])) {
                val = val * 10 + (expr[i+1] - '0');
                i++;
            }
            push(&val_stack, val);
        } else if (is_operator(ch)) {
            while (!is_empty(&op_stack) && precedence(ch) <= precedence(peek(&op_stack))) {
                val1 = pop(&val_stack);
                val2 = pop(&val_stack);
                op = pop(&op_stack);
                if (op == '+') {
                    push(&val_stack, val2 + val1);
                } else if (op == '-') {
                    push(&val_stack, val2 - val1);
                } else if (op == '*') {
                    push(&val_stack, val2 * val1);
                } else if (op == '/') {
                    push(&val_stack, val2 / val1);
                }
            }
            push(&op_stack, ch);
        } else if (ch == '(') {
            push(&op_stack, ch);
        } else if (ch == ')') {
            while (peek(&op_stack) != '(') {
                val1 = pop(&val_stack);
                val2 = pop(&val_stack);
                op = pop(&op_stack);
                if (op == '+') {
                    push(&val_stack, val2 + val1);
                } else if (op == '-') {
                    push(&val_stack, val2 - val1);
                } else if (op == '*') {
                    push(&val_stack, val2 * val1);
                } else if (op == '/') {
                    push(&val_stack, val2 / val1);
                }
            }
            pop(&op_stack);
        }
    }
    while (!is_empty(&op_stack)) {
        val1 = pop(&val_stack);
        val2 = pop(&val_stack);
        op = pop(&op_stack);
        if (op == '+') {
            push(&val_stack, val2 + val1);
        } else if (op == '-') {
            push(&val_stack, val2 - val1);
        } else if (op == '*') {
            push(&val_stack, val2 * val1);
        } else if (op == '/') {
            push(&val_stack, val2 / val1);
        }
    }
    return pop(&val_stack);
}

int main() {
    char expr[MAX_SIZE];
    printf("Enter an infix expression: ");
    fgets(expr, MAX_SIZE, stdin);
    int result = evaluate(expr);
    printf("Result: %d\n", result);
    return 0;
}