计算表达式 / int calculate(char expression) { int num_stack[MAX_SIZE]; char op_stack[MAX_SIZE]; int num_top = -1, op_top = -1; int len = strlen(expression); for (int i = 0; i < len; i++) { if (expression[i] == '(') { op_stack[++op_top] = '('; } else if (expression[i] == ')') { while (op_top >= 0 && op_stack[op_top] != '(') { char op = op_stack[op_top--]; int num2 = num_stack[num_top--]; int num1 = num_stack[num_top--]; if (op == '+') { num_stack[++num_top] = num1 + num2; } else if (op == '-') { num_stack[++num_top] = num1 - num2; } else if (op == '') { num_stack[++num_top] = num1 * num2; } else if (op == '/') { num_stack[++num_top] = num1 / num2; } } if (op_stack[op_top] == '(') { op_top--; } } else if (is_digit(expression[i])) { int num = 0; while (i < len && is_digit(expression[i])) { num = num * 10 + expression[i] - '0'; i++; } i--; num_stack[++num_top] = num; } else if (is_operator(expression[i])) { while (op_top >= 0 && op_stack[op_top] != '(' && priority(op_stack[op_top]) >= priority(expression[i])) { char op = op_stack[op_top--]; int num2 = num_stack[num_top--]; int num1 = num_stack[num_top--]; if (op == '+') { num_stack[++num_top] = num1 + num2; } else if (op == '-') { num_stack[++num_top] = num1 - num2; } else if (op == '') { num_stack[++num_top] = num1 * num2; } else if (op == '/') { num_stack[++num_top] = num1 / num2; } } op_stack[++op_top] = expression[i]; } } while (op_top >= 0) { char op = op_stack[op_top--]; int num2 = num_stack[num_top--]; int num1 = num_stack[num_top--]; if (op == '+') { num_stack[++num_top] = num1 + num2; } else if (op == '-') { num_stack[++num_top] = num1 - num2; } else if (op == '*') { num_stack[++num_top] = num1 * num2; } else if (op == '/') { num_stack[++num_top] = num1 / num2; } } return num_stack[num_top]; }分析这段代码

这段代码是一个计算表达式的函数，使用了栈来实现。函数的参数是一个字符串表达式，返回值是该表达式的计算结果。函数使用了两个栈，一个存放数字，一个存放运算符。遍历表达式字符串，如果遇到左括号，则将左括号入栈，如果遇到右括号，则将栈顶的运算符和数字出栈，进行计算，直到遇到左括号为止。如果遇到数字，则将数字入数字栈，如果遇到运算符，则将栈顶的运算符和数字出栈，进行计算，直到栈顶运算符的优先级小于当前运算符为止，然后将当前运算符入运算符栈。最后，如果运算符栈不为空，则继续进行计算，直到运算符栈为空。最后返回数字栈的栈顶元素作为表达式的计算结果。

相关问题

计算后缀表达式的C语言

计算后缀表达式的C语言程序需要用到栈来辅助实现。具体步骤如下：
1. 从控制台输入后缀表达式，以空格为分割输入。
2. 遍历输入的字符串，如果是数字则直接入栈，如果是运算符则弹出栈顶的两个元素进行运算，并将结果入栈。
3. 如果遍历完字符串后栈中只有一个元素，则该元素即为表达式的结果。
4. 在运算过程中需要注意表达式错误检测异常，例如除数为0等情况。

下面是一个简单的计算后缀表达式的C语言程序：

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

#define MAX_STACK_SIZE 100

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

void initStack(Stack *s) {
    s->top = -1;
}

int isEmpty(Stack *s) {
    return s->top == -1;
}

int isFull(Stack *s) {
    return s->top == MAX_STACK_SIZE - 1;
}

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

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

int calculate(char *expr) {
    Stack s;
    initStack(&s);
    int i = 0;
    while (expr[i] != '\0') {
        if (isdigit(expr[i])) {
            int num = 0;
            while (isdigit(expr[i])) {
                num = num * 10 + (expr[i] - '0');
                i++;
            }
            push(&s, num);
        } else if (expr[i] == '+' || expr[i] == '-' || expr[i] == '*' || expr[i] == '/') {
            int op1 = pop(&s);
            int op2 = pop(&s);
            int result;
            switch (expr[i]) {
                case '+':
                    result = op2 + op1;
                    break;
                case '-':
                    result = op2 - op1;
                    break;
                case '*':
                    result = op2 * op1;
                    break;
                case '/':
                    if (op1 == 0) {
                        printf("Divide by zero\n");
                        exit(1);
                    }
                    result = op2 / op1;
                    break;
            }
            push(&s, result);
            i++;
        } else {
            printf("Invalid character\n");
            exit(1);
        }
    }
    if (isEmpty(&s)) {
        printf("Empty expression\n");
        exit(1);
    }
    int result = pop(&s);
    if (!isEmpty(&s)) {
        printf("Invalid expression\n");
        exit(1);
    }
    return result;
}

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

中缀表达式计算c语言

中缀表达式计算可以通过将中缀表达式转换为后缀表达式，然后再利用栈来计算后缀表达式的值。具体的实现步骤如下：

1. 定义一个运算符栈和一个操作数栈；
2. 从左向右扫描中缀表达式，如果是数字，则直接入操作数栈，如果是运算符，则按照下列规则处理：
a. 如果运算符栈为空，或者栈顶运算符为左括号，则直接入栈；
b. 如果优先级比栈顶运算符的优先级高，则直接入栈；
c. 如果优先级比栈顶运算符的优先级低或者相等，则将栈顶运算符弹出，并将其加入到后缀表达式中，然后重复步骤2，直到满足条件a或b为止；
d. 如果是左括号，则直接入栈；
e. 如果是右括号，则将运算符栈中的运算符弹出并加入到后缀表达式中，直到弹出左括号为止；
3. 如果扫描完毕，但是运算符栈中还有运算符，则依次弹出并加入到后缀表达式中；
4. 利用操作数栈和后缀表达式来计算表达式的值。

以下是一个示例代码，可以实现中缀表达式计算：

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

#define MAX_SIZE 100

typedef struct {
    int top;
    char 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;
}

int push(Stack *s, char ch) {
    if (is_full(s)) {
        return 0;
    }
    s->data[++s->top] = ch;
    return 1;
}

char pop(Stack *s) {
    if (is_empty(s)) {
        return '\0';
    }
    return s->data[s->top--];
}

char peek(Stack *s) {
    if (is_empty(s)) {
        return '\0';
    }
    return s->data[s->top];
}

int is_operator(char ch) {
    return ch == '+' || ch == '-' || ch == '*' || ch == '/';
}

int get_priority(char ch) {
    if (ch == '+' || ch == '-') {
        return 1;
    } else if (ch == '*' || ch == '/') {
        return 2;
    }
    return 0;
}

int infix_to_postfix(char *infix, char *postfix) {
    Stack op_stack;
    init(&op_stack);
    int i, j;
    for (i = 0, j = 0; infix[i]; i++) {
        if (isdigit(infix[i])) {
            postfix[j++] = infix[i];
        } else if (is_operator(infix[i])) {
            while (!is_empty(&op_stack) && peek(&op_stack) != '(' 
                    && get_priority(peek(&op_stack)) >= get_priority(infix[i])) {
                postfix[j++] = pop(&op_stack);
            }
            push(&op_stack, infix[i]);
        } else if (infix[i] == '(') {
            push(&op_stack, infix[i]);
        } else if (infix[i] == ')') {
            while (!is_empty(&op_stack) && peek(&op_stack) != '(') {
                postfix[j++] = pop(&op_stack);
            }
            if (!is_empty(&op_stack) && peek(&op_stack) == '(') {
                pop(&op_stack);
            }
        }
    }
    while (!is_empty(&op_stack)) {
        postfix[j++] = pop(&op_stack);
    }
    postfix[j] = '\0';
    return 1;
}

int calculate(char *postfix) {
    Stack num_stack;
    init(&num_stack);
    int i, num;
    for (i = 0; postfix[i]; i++) {
        if (isdigit(postfix[i])) {
            num = postfix[i] - '0';
            push(&num_stack, num);
        } else if (is_operator(postfix[i])) {
            int num2 = pop(&num_stack);
            int num1 = pop(&num_stack);
            switch (postfix[i]) {
                case '+':
                    push(&num_stack, num1 + num2);
                    break;
                case '-':
                    push(&num_stack, num1 - num2);
                    break;
                case '*':
                    push(&num_stack, num1 * num2);
                    break;
                case '/':
                    push(&num_stack, num1 / num2);
                    break;
            }
        }
    }
    return pop(&num_stack);
}

int main() {
    char infix[MAX_SIZE], postfix[MAX_SIZE];
    printf("Enter an infix expression: ");
    scanf("%s", infix);
    infix_to_postfix(infix, postfix);
    printf("Postfix expression: %s\n", postfix);
    printf("Result: %d\n", calculate(postfix));
    return 0;
}

注意：这段代码中没有处理错误情况，例如表达式不合法等情况，实际使用中需要根据具体情况进行处理。