C语言栈实现算数表达式求值代码

下面是一个基于C语言栈实现算数表达式求值的代码示例：

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

#define MAX_SIZE 100

// 定义栈的数据结构
typedef struct Stack {
    int top;         // 栈顶指针
    int data[MAX_SIZE];   // 存储数据的数组
} Stack;

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

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

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

// 入栈
void push(Stack *stack, int item) {
    if (isFull(stack)) {
        printf("Stack Overflow.\n");
        exit(EXIT_FAILURE);
    }
    stack->data[++stack->top] = item;
}

// 出栈
int pop(Stack *stack) {
    if (isEmpty(stack)) {
        printf("Stack Underflow.\n");
        exit(EXIT_FAILURE);
    }
    return stack->data[stack->top--];
}

// 取栈顶元素
int peek(Stack *stack) {
    if (isEmpty(stack)) {
        printf("Stack Underflow.\n");
        exit(EXIT_FAILURE);
    }
    return stack->data[stack->top];
}

// 判断是否为操作符
int isOperator(char ch) {
    return ch == '+' || ch == '-' || ch == '*' || ch == '/';
}

// 获取操作符的优先级，返回值越大优先级越高
int getPriority(char op) {
    switch (op) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        default:
            return 0;
    }
}

// 对表达式进行求值
int evaluate(char *expression) {
    Stack operands, operators;
    int i, n, val, op1, op2;
    char ch, prev;

    // 初始化两个栈
    init(&operands);
    init(&operators);

    n = strlen(expression);
    prev = '\0';

    for (i = 0; i < n; i++) {
        ch = expression[i];

        // 如果是空白字符，则跳过
        if (isspace(ch)) {
            continue;
        }

        // 如果是数字，则将其入栈
        if (isdigit(ch)) {
            val = ch - '0';

            // 取多位数
            while (i + 1 < n && isdigit(expression[i + 1])) {
                val = val * 10 + (expression[++i] - '0');
            }

            // 如果前一个字符是')'，说明当前数字是括号内的第一个数，直接入栈
            // 否则，说明前一个数和当前数构成一位多位数，需要将其弹出并计算
            if (prev != ')') {
                op1 = pop(&operands);
                val = op1 * 10 + val;
            }

            push(&operands, val);
        }
        // 如果是'('，则直接入栈
        else if (ch == '(') {
            push(&operators, ch);
        }
        // 如果是')'，则将运算符栈中'('上面的所有运算符取出并计算
        else if (ch == ')') {
            while (peek(&operators) != '(') {
                op2 = pop(&operands);
                op1 = pop(&operands);
                val = pop(&operators);

                switch (val) {
                    case '+':
                        val = op1 + op2;
                        break;
                    case '-':
                        val = op1 - op2;
                        break;
                    case '*':
                        val = op1 * op2;
                        break;
                    case '/':
                        val = op1 / op2;
                        break;
                }

                push(&operands, val);
            }
            // 弹出'('
            pop(&operators);
        }
        // 如果是操作符，则将其入栈，
        // 并将运算符栈中优先级大于等于当前操作符的运算符取出并计算
        else if (isOperator(ch)) {
            while (!isEmpty(&operators) && peek(&operators) != '('
                   && getPriority(peek(&operators)) >= getPriority(ch)) {
                op2 = pop(&operands);
                op1 = pop(&operands);
                val = pop(&operators);

                switch (val) {
                    case '+':
                        val = op1 + op2;
                        break;
                    case '-':
                        val = op1 - op2;
                        break;
                    case '*':
                        val = op1 * op2;
                        break;
                    case '/':
                        val = op1 / op2;
                        break;
                }

                push(&operands, val);
            }

            // 将当前操作符入栈
            push(&operators, ch);
        }

        prev = ch;
    }

    // 处理所有剩余的操作符
    while (!isEmpty(&operators)) {
        op2 = pop(&operands);
        op1 = pop(&operands);
        val = pop(&operators);

        switch (val) {
            case '+':
                val = op1 + op2;
                break;
            case '-':
                val = op1 - op2;
                break;
            case '*':
                val = op1 * op2;
                break;
            case '/':
                val = op1 / op2;
                break;
        }

        push(&operands, val);
    }

    return pop(&operands);
}

// 测试函数
int main() {
    char expression[100];

    printf("Enter an arithmetic expression: ");
    fgets(expression, 100, stdin);

    printf("Result: %d\n", evaluate(expression));

    return 0;
}

这个代码实现了基本的四则运算和括号优先级，可以处理多位数和负数。不过可能还存在一些漏洞，需要自己进一步完善和测试。