用C语言栈结构实现：编程实现四则运算表达式的运算。 输入说明：通过控制台输入四则运算表达式，表达式不超过40个字符，以“=”作为结束符，例如：3 + 2 *（5+2）=。 输入假设：所有操作数均为正数。 输出说明：计算结果从控制台输出给用户，结果精确到小数点后2位。或者输出错误ERROR。 1、创建运算符优先级静态表，并实现运算符优先级查找函数Precede(x, y)。参数x，y是四则运算符，包括+、－、*、\、(、)、=。 2、应用Precede()函数，编写程序计算中缀表达式（一般表达式）的值。 三、问题分析 采用中缀表达式求解过程中，首先需要按照顺序读取数字和操作符，将它们分别保存。如果最先保存的操作符优先级不大于接下来保存的操作符，将一直不被调用指导上一级操作符被调用，满足先进后出的数据结构，所以用栈来保存操作符（本实验称之为符号栈）。对于保存的数字，每次调用操作符时，同时将最后保存的两位数字调用，满足先进后出的数据结构，所以用栈来保存操作符（本实验称之为数字栈）。运算先后由下一个操作符和栈顶操作符的优先级确定，当发现下一个符号的优先级小于栈顶符号的优先级，则需要先进行栈顶符号的运算，此时数字栈的最上面两个数字恰好是该符号的运算数。 测试用例 输入(2.3*4+1.6/2)*2.1-1.3+2.1*2= 输出 The result is:23.9

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

#define MAXSIZE 50

// 运算符优先级静态表
char Precede[7][7] = {
    {'>', '>', '<', '<', '<', '>', '>'},
    {'>', '>', '<', '<', '<', '>', '>'},
    {'>', '>', '>', '>', '<', '>', '>'},
    {'>', '>', '>', '>', '<', '>', '>'},
    {'<', '<', '<', '<', '<', '=', 'E'},
    {'>', '>', '>', '>', 'E', '>', '>'},
    {'<', '<', '<', '<', '<', 'E', '='}
};

typedef struct {
    double data[MAXSIZE];
    int top;
} NumberStack;  // 数字栈

typedef struct {
    char data[MAXSIZE];
    int top;
} SymbolStack;  // 符号栈

void InitStack(NumberStack *s) {
    s->top = -1;
}

void InitStack(SymbolStack *s) {
    s->top = -1;
}

int Push(NumberStack *s, double e) {
    if (s->top == MAXSIZE - 1) {
        return 0;  // 栈满
    } else {
        s->top++;
        s->data[s->top] = e;
        return 1;
    }
}

int Push(SymbolStack *s, char e) {
    if (s->top == MAXSIZE - 1) {
        return 0;  // 栈满
    } else {
        s->top++;
        s->data[s->top] = e;
        return 1;
    }
}

int Pop(NumberStack *s, double *e) {
    if (s->top == -1) {
        return 0;  // 栈空
    } else {
        *e = s->data[s->top];
        s->top--;
        return 1;
    }
}

int Pop(SymbolStack *s, char *e) {
    if (s->top == -1) {
        return 0;  // 栈空
    } else {
        *e = s->data[s->top];
        s->top--;
        return 1;
    }
}

int GetTop(NumberStack *s, double *e) {
    if (s->top == -1) {
        return 0;  // 栈空
    } else {
        *e = s->data[s->top];
        return 1;
    }
}

int GetTop(SymbolStack *s, char *e) {
    if (s->top == -1) {
        return 0;  // 栈空
    } else {
        *e = s->data[s->top];
        return 1;
    }
}

int IsEmpty(NumberStack *s) {
    return s->top == -1;
}

int IsEmpty(SymbolStack *s) {
    return s->top == -1;
}

// 运算符优先级查找函数
char PrecedeFunc(char a, char b) {
    int i, j;
    switch (a) {
        case '+':
            i = 0;
            break;
        case '-':
            i = 1;
            break;
        case '*':
            i = 2;
            break;
        case '/':
            i = 3;
            break;
        case '(':
            i = 4;
            break;
        case ')':
            i = 5;
            break;
        case '=':
            i = 6;
            break;
    }
    switch (b) {
        case '+':
            j = 0;
            break;
        case '-':
            j = 1;
            break;
        case '*':
            j = 2;
            break;
        case '/':
            j = 3;
            break;
        case '(':
            j = 4;
            break;
        case ')':
            j = 5;
            break;
        case '=':
            j = 6;
            break;
    }
    return Precede[i][j];
}

// 中缀表达式求值
double EvaluateExpression(char *exp) {
    NumberStack numStack;  // 数字栈
    SymbolStack symStack;  // 符号栈
    double a, b, result;
    char c, topSym;

    InitStack(&numStack);
    InitStack(&symStack);
    Push(&symStack, '=');  // 将=入栈

    c = *exp++;
    while (c != '=' || topSym != '=') {
        if (isdigit(c) || c == '.') {  // 数字
            exp--;
            scanf(exp, "%lf", &a);
            while (isdigit(*exp) || *exp == '.') {
                exp++;
            }
            Push(&numStack, a);
            c = *exp++;
        } else {  // 符号
            GetTop(&symStack, &topSym);  // 获取符号栈栈顶元素
            switch (PrecedeFunc(topSym, c)) {
                case '<':  // 栈顶元素优先级低
                    Push(&symStack, c);  // 将当前符号入栈
                    c = *exp++;
                    break;
                case '=':  // 匹配到了"="
                    Pop(&symStack, &topSym);  // 弹出"="
                    c = *exp++;
                    break;
                case '>':  // 栈顶元素优先级高
                    Pop(&symStack, &topSym);  // 弹出栈顶元素
                    Pop(&numStack, &b);  // 弹出数字栈栈顶元素
                    Pop(&numStack, &a);  // 弹出数字栈次顶元素
                    switch (topSym) {
                        case '+':
                            result = a + b;
                            break;
                        case '-':
                            result = a - b;
                            break;
                        case '*':
                            result = a * b;
                            break;
                        case '/':
                            if (b == 0) {
                                return -1;  // 错误：除数为0
                            }
                            result = a / b;
                            break;
                    }
                    Push(&numStack, result);  // 将计算结果入栈
                    break;
            }
        }
    }

    GetTop(&numStack, &result);  // 获取数字栈栈顶元素
    return result;
}

int main() {
    char exp[40];
    double result;

    printf("请输入四则运算表达式（以=结束）：\n");
    scanf("%s", exp);

    result = EvaluateExpression(exp);
    if (result == -1) {
        printf("ERROR\n");
    } else {
        printf("The result is:%.2lf\n", result);
    }

    return 0;
}