用c语言编写可以计算中缀算式的程序

好的，这里为您提供一个用C语言编写的可以计算中缀算式的程序实现。

首先，您需要定义一个栈结构体来存储算式中的操作数和操作符。这个栈可以使用数组来实现。例如：

#define STACK_SIZE 100

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

接下来，您可以编写一个函数来判断一个字符是否是操作符。例如：

int isOperator(char c) {
    return c == '+' || c == '-' || c == '*' || c == '/';
}

然后，您需要实现一个函数来将中缀算式转换为后缀算式。这个函数可以使用栈和队列来实现。例如：

typedef struct {
    double data[STACK_SIZE];
    int front;
    int rear;
} Queue;

void infixToPostfix(char* infix, char* postfix) {
    Stack opStack;
    opStack.top = -1;
    Queue outputQueue;
    outputQueue.front = 0;
    outputQueue.rear = -1;

    int i = 0;
    while(infix[i] != '\0') {
        if(isdigit(infix[i])) {
            // 如果当前字符是数字，则将其加入输出队列
            double operand = 0;
            while(isdigit(infix[i])) {
                operand = operand * 10 + (infix[i] - '0');
                i++;
            }
            if(infix[i] == '.') {
                i++;
                double fraction = 0.1;
                while(isdigit(infix[i])) {
                    operand += fraction * (infix[i] - '0');
                    fraction /= 10;
                    i++;
                }
            }
            outputQueue.rear++;
            outputQueue.data[outputQueue.rear] = operand;
        }
        else if(isOperator(infix[i])) {
            // 如果当前字符是操作符，则将其加入操作符栈，直到遇到优先级更低的操作符或左括号
            while(opStack.top >= 0 && opStack.data[opStack.top] != '(' && ((infix[i] == '+' || infix[i] == '-') && (opStack.data[opStack.top] == '*' || opStack.data[opStack.top] == '/'))) {
                outputQueue.rear++;
                outputQueue.data[outputQueue.rear] = opStack.data[opStack.top];
                opStack.top--;
            }
            opStack.top++;
            opStack.data[opStack.top] = infix[i];
            i++;
        }
        else if(infix[i] == '(') {
            // 如果当前字符是左括号，则将其加入操作符栈
            opStack.top++;
            opStack.data[opStack.top] = infix[i];
            i++;
        }
        else if(infix[i] == ')') {
            // 如果当前字符是右括号，则将操作符栈中的操作符加入输出队列，直到遇到左括号
            while(opStack.top >= 0 && opStack.data[opStack.top] != '(') {
                outputQueue.rear++;
                outputQueue.data[outputQueue.rear] = opStack.data[opStack.top];
                opStack.top--;
            }
            if(opStack.top >= 0 && opStack.data[opStack.top] == '(') {
                opStack.top--;
            }
            i++;
        }
        else {
            // 否则忽略当前字符
            i++;
        }
    }

    // 将操作符栈中的所有操作符加入输出队列
    while(opStack.top >= 0) {
        outputQueue.rear++;
        outputQueue.data[outputQueue.rear] = opStack.data[opStack.top];
        opStack.top--;
    }

    // 将后缀算式输出到postfix数组中
    int j = 0;
    while(outputQueue.front <= outputQueue.rear) {
        double data = outputQueue.data[outputQueue.front];
        outputQueue.front++;
        if(data == '+') {
            postfix[j] = '+';
            j++;
        }
        else if(data == '-') {
            postfix[j] = '-';
            j++;
        }
        else if(data == '*') {
            postfix[j] = '*';
            j++;
        }
        else if(data == '/') {
            postfix[j] = '/';
            j++;
        }
        else {
            sprintf(&postfix[j], "%.2f", data);
            j += strlen(&postfix[j]);
        }
    }
    postfix[j] = '\0';
}

最后，您可以编写一个函数来计算后缀算式的结果。这个函数可以使用栈来实现。例如：

double calculate(char* postfix) {
    Stack stack;
    stack.top = -1;

    int i = 0;
    while(postfix[i] != '\0') {
        if(isdigit(postfix[i])) {
            // 如果当前字符是数字，则将其加入栈中
            double operand = 0;
            while(isdigit(postfix[i])) {
                operand = operand * 10 + (postfix[i] - '0');
                i++;
            }
            if(postfix[i] == '.') {
                i++;
                double fraction = 0.1;
                while(isdigit(postfix[i])) {
                    operand += fraction * (postfix[i] - '0');
                    fraction /= 10;
                    i++;
                }
            }
            stack.top++;
            stack.data[stack.top] = operand;
        }
        else if(isOperator(postfix[i])) {
            // 如果当前字符是操作符，则从栈中弹出两个操作数，并将计算结果入栈
            double operand2 = stack.data[stack.top];
            stack.top--;
            double operand1 = stack.data[stack.top];
            stack.top--;
            switch(postfix[i]) {
                case '+':
                    stack.top++;
                    stack.data[stack.top] = operand1 + operand2;
                    break;
                case '-':
                    stack.top++;
                    stack.data[stack.top] = operand1 - operand2;
                    break;
                case '*':
                    stack.top++;
                    stack.data[stack.top] = operand1 * operand2;
                    break;
                case '/':
                    stack.top++;
                    stack.data[stack.top] = operand1 / operand2;
                    break;
                //TODO: 添加更多的操作符
            }
            i++;
        }
        else {
            // 否则忽略当前字符
            i++;
        }
    }

    // 返回栈顶元素作为计算结果
    return stack.data[stack.top];
}

最后，您可以编写一个主函数来调用infixToPostfix和calculate函数，并将结果输出给用户。例如：

int main() {
    char infix[100];
    char postfix[100];
    printf("请输入一个中缀算式：");
    scanf("%s", infix);
    infixToPostfix(infix, postfix);
    double result = calculate(postfix);
    printf("结果为：%f\n", result);
    return 0;
}

当然，这只是一个简单的实现思路，您可以根据自己的需要进一步完善和扩展。