用户从键盘输入一个算术表达式，数字都是十进制整型（必须支持负数），运算符支持+-*/()。编写源程序中的 ​​​​double deal_exp (char *exp) 函数，对这个算术表达式求值，返回结果，用c语言编写

这里提供一个基于栈的算法实现：

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

#define MAXSIZE 100

typedef struct {
    double data[MAXSIZE];
    int top;
} Stack;

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

int push(Stack *s, double x) {
    if (s->top == MAXSIZE - 1) {
        return 0;
    }
    s->data[++s->top] = x;
    return 1;
}

double pop(Stack *s) {
    if (s->top == -1) {
        return 0;
    }
    return s->data[s->top--];
}

double peek(Stack *s) {
    if (s->top == -1) {
        return 0;
    }
    return s->data[s->top];
}

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

double deal_exp(char *exp) {
    Stack num_stack, op_stack;
    init(&num_stack);
    init(&op_stack);

    int i = 0;
    while (exp[i] != '\0') {
        if (isdigit(exp[i])) {
            double num = exp[i] - '0';
            i++;
            while (isdigit(exp[i])) {
                num = num * 10 + (exp[i] - '0');
                i++;
            }
            if (exp[i] == '.') {
                i++;
                double frac = 0.1;
                while (isdigit(exp[i])) {
                    num += (exp[i] - '0') * frac;
                    frac *= 0.1;
                    i++;
                }
            }
            push(&num_stack, num);
        } else if (exp[i] == '+' || exp[i] == '-') {
            while (!isempty(&op_stack) && peek(&op_stack) != '(') {
                double b = pop(&num_stack);
                double a = pop(&num_stack);
                char op = pop(&op_stack);
                if (op == '+') {
                    push(&num_stack, a + b);
                } else {
                    push(&num_stack, a - b);
                }
            }
            push(&op_stack, exp[i]);
            i++;
        } else if (exp[i] == '*' || exp[i] == '/') {
            while (!isempty(&op_stack) && (peek(&op_stack) == '*' || peek(&op_stack) == '/')) {
                double b = pop(&num_stack);
                double a = pop(&num_stack);
                char op = pop(&op_stack);
                if (op == '*') {
                    push(&num_stack, a * b);
                } else {
                    push(&num_stack, a / b);
                }
            }
            push(&op_stack, exp[i]);
            i++;
        } else if (exp[i] == '(') {
            push(&op_stack, exp[i]);
            i++;
        } else if (exp[i] == ')') {
            while (!isempty(&op_stack) && peek(&op_stack) != '(') {
                double b = pop(&num_stack);
                double a = pop(&num_stack);
                char op = pop(&op_stack);
                if (op == '+') {
                    push(&num_stack, a + b);
                } else if (op == '-') {
                    push(&num_stack, a - b);
                } else if (op == '*') {
                    push(&num_stack, a * b);
                } else {
                    push(&num_stack, a / b);
                }
            }
            if (!isempty(&op_stack) && peek(&op_stack) == '(') {
                pop(&op_stack);
            }
            i++;
        } else {
            i++;
        }
    }

    while (!isempty(&op_stack)) {
        double b = pop(&num_stack);
        double a = pop(&num_stack);
        char op = pop(&op_stack);
        if (op == '+') {
            push(&num_stack, a + b);
        } else if (op == '-') {
            push(&num_stack, a - b);
        } else if (op == '*') {
            push(&num_stack, a * b);
        } else {
            push(&num_stack, a / b);
        }
    }

    return pop(&num_stack);
}

int main() {
    char exp[100];
    printf("请输入算术表达式：");
    scanf("%s", exp);
    double result = deal_exp(exp);
    printf("结果为：%.6f\n", result);
    return 0;
}

这个算法的思路是，使用两个栈，一个存储数字，一个存储操作符。遍历表达式中的每个字符，如果是数字，则将其转化为 double 类型后压入数字栈；如果是加减乘除，则将其与操作符栈顶元素比较优先级，如果优先级更高或相等，则从数字栈中弹出两个数，从操作符栈中弹出一个操作符，进行计算后将结果压入数字栈；如果是左括号，则直接压入操作符栈；如果是右括号，则将操作符栈中的操作符依次弹出，从数字栈中弹出两个数进行计算，直到遇到左括号为止。最后，将操作符栈中剩余的操作符依次弹出，进行计算，直到操作符栈为空。最后数字栈中剩下的唯一元素就是表达式的值。