、用C语言写一个代码建立表达式二叉树并计算其结果(即输入一个四则混合运算表达式并计算出正确结果)

好的，下面是代码：

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

typedef struct node {
    char data; // 节点存储的数据
    struct node *left; // 左子树
    struct node *right; // 右子树
} Node;

// 创建节点
Node *createNode(char data) {
    Node *newNode = (Node *) malloc(sizeof(Node));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 销毁节点
void destroyNode(Node *node) {
    if (node == NULL) {
        return;
    }
    destroyNode(node->left);
    destroyNode(node->right);
    free(node);
}

// 释放表达式二叉树占用的内存
void freeTree(Node *root) {
    destroyNode(root);
}

// 构建表达式二叉树
Node *buildExpressionTree(char *expression, int start, int end) {
    // 如果表达式只有一个字符，则构建一个节点并返回
    if (start == end) {
        return createNode(expression[start]);
    }

    // 找到当前表达式中优先级最低的运算符
    int priority = 0;
    int operatorIndex = -1;
    for (int i = start; i <= end; i++) {
        if (expression[i] == '(') {
            priority += 10;
        } else if (expression[i] == ')') {
            priority -= 10;
        } else if (isdigit(expression[i])) {
            continue;
        } else if (priority == 0) {
            int currentPriority = 0;
            if (expression[i] == '+' || expression[i] == '-') {
                currentPriority = 1;
            } else if (expression[i] == '*' || expression[i] == '/') {
                currentPriority = 2;
            }
            if (currentPriority <= priority) {
                priority = currentPriority;
                operatorIndex = i;
            }
        }
    }

    // 如果表达式中没有运算符，则构建一个节点并返回
    if (operatorIndex == -1) {
        return createNode(expression[start]);
    }

    // 递归构建左右子树
    Node *root = createNode(expression[operatorIndex]);
    root->left = buildExpressionTree(expression, start, operatorIndex - 1);
    root->right = buildExpressionTree(expression, operatorIndex + 1, end);
    return root;
}

// 计算表达式二叉树的结果
int calculateExpressionTree(Node *root) {
    if (root == NULL) {
        return 0;
    }

    // 如果当前节点是数字，则返回它存储的值
    if (isdigit(root->data)) {
        return root->data - '0';
    }

    // 分别计算左右子树的结果
    int leftResult = calculateExpressionTree(root->left);
    int rightResult = calculateExpressionTree(root->right);

    // 根据当前节点的运算符计算结果并返回
    switch (root->data) {
        case '+':
            return leftResult + rightResult;
        case '-':
            return leftResult - rightResult;
        case '*':
            return leftResult * rightResult;
        case '/':
            return leftResult / rightResult;
        default:
            return 0;
    }
}

int main() {
    char expression[100];
    printf("请输入一个四则混合运算表达式：\n");
    scanf("%s", expression);

    Node *root = buildExpressionTree(expression, 0, strlen(expression) - 1);
    int result = calculateExpressionTree(root);
    printf("表达式的计算结果为：%d\n", result);

    freeTree(root);
    return 0;
}

这个代码中，我们首先定义了一个 `Node` 结构体，用来表示表达式二叉树的节点。其中，`data` 表示节点存储的数据，`left` 和 `right` 分别指向左子树和右子树。

然后，我们定义了三个函数：

- `createNode`：用来创建一个新的表达式二叉树节点。
- `destroyNode`：用来销毁一个表达式二叉树节点及其所有子节点。
- `freeTree`：用来释放整个表达式二叉树占用的内存。

接下来，我们定义了 `buildExpressionTree` 函数，用来构建表达式二叉树。这个函数使用递归的方法，先找到当前表达式中优先级最低的运算符，然后将它作为根节点，递归构建左右子树。如果表达式中没有运算符，则构建一个节点并返回。

最后，我们定义了 `calculateExpressionTree` 函数，用来计算表达式二叉树的结果。这个函数也使用递归的方法，先判断当前节点是不是数字，如果是，则返回它存储的值。如果不是，则分别计算左右子树的结果，然后根据当前节点的运算符计算结果并返回。

在 `main` 函数中，我们首先读入一个四则混合运算表达式，然后调用 `buildExpressionTree` 函数构建表达式二叉树，再调用 `calculateExpressionTree` 函数计算表达式的结果，并输出结果。

最后，我们调用 `freeTree` 函数释放表达式二叉树占用的内存。