表达式二叉树 中序遍历

表达式树 代码实现 中序遍历

来自《数据结构与算法分析——C语言描述》

节点类型 定义

typedef struct BinaryTreeNode {
	union element{
        int operand;//操作数
        char operator;//操作符
    }element;
	struct BinaryTreeNode* Left;
	struct BinaryTreeNode* Right;
}BinaryTreeNode_T;

中序遍历代码

void calculate_test(BinaryTreeNode_T* T) {
    if (T == NULL) {
        return;
    }
    if (T->Left != NULL) {//目前仅考虑要么两个儿子都有，要么没有儿子，即二元操作符和操作数
        printf("\(");
        calculate_test(T->Left);//左
        printf("%c", T->element.operator);//有两儿子的中序打印操作符
        calculate_test(T->Right);//右
        printf("\)");
    }
    else {//是操作数
        printf("%d", T->element.operand);//操作数直接打印，没有儿子
    }
}

建立二叉树并测试

在主函数中调用

void ExpressionTreeTest(void){
    //新建一个表达式二叉树
    int a = 3;
    int b = 5;
    int c = 6;
    int d = 10;
    int e = 11;
    int f = 12;
    int g = 13;

    BinaryTreeNode_T* node1 = malloc(sizeof(BinaryTreeNode_T));
    BinaryTreeNode_T* node2 = malloc(sizeof(BinaryTreeNode_T));
    BinaryTreeNode_T* node3 = malloc(sizeof(BinaryTreeNode_T));
    BinaryTreeNode_T* node4 = malloc(sizeof(BinaryTreeNode_T));
    BinaryTreeNode_T* node5 = malloc(sizeof(BinaryTreeNode_T));
    BinaryTreeNode_T* node6 = malloc(sizeof(BinaryTreeNode_T));
    BinaryTreeNode_T* node7 = malloc(sizeof(BinaryTreeNode_T));
    BinaryTreeNode_T* node8 = malloc(sizeof(BinaryTreeNode_T));
    BinaryTreeNode_T* node9 = malloc(sizeof(BinaryTreeNode_T));
    BinaryTreeNode_T* node10 = malloc(sizeof(BinaryTreeNode_T));
    BinaryTreeNode_T* node11 = malloc(sizeof(BinaryTreeNode_T));
    BinaryTreeNode_T* node12 = malloc(sizeof(BinaryTreeNode_T));
    BinaryTreeNode_T* node13 = malloc(sizeof(BinaryTreeNode_T));

    node1->element.operator = '+';
    node1->Left = node2;
    node1->Right = node7;

    node2->element.operator = '+';
    node2->Left = node3;
    node2->Right = node4;

    node3->element.operand = a;
    node3->Left = NULL;
    node3->Right = NULL;

    node4->element.operator = '*';
    node4->Left = node5;
    node4->Right = node6;

    node5->element.operand = b;
    node5->Left = NULL;
    node5->Right = NULL;

    node6->element.operand = c;
    node6->Left = NULL;
    node6->Right = NULL;

    node7->element.operator = '*';
    node7->Left = node8;
    node7->Right = node13;

    node8->element.operator = '+';
    node8->Left = node9;
    node8->Right = node12;

    node9->element.operator = '*';
    node9->Left = node10;
    node9->Right = node11;

    node10->element.operand = d;
    node10->Left = NULL;
    node10->Right = NULL;

    node11->element.operand = e;
    node11->Left = NULL;
    node11->Right = NULL;

    node12->element.operand = f;
    node12->Left = NULL;
    node12->Right = NULL;

    node13->element.operand = g;
    node13->Left = NULL;
    node13->Right = NULL;

    //测试

    calculate_test(node1);
    //内存释放
    free(node1);
    free(node2);
    free(node3);
    free(node4);
    free(node5);
    free(node6);
    free(node7);
    free(node8);
    free(node9);
    free(node10);
    free(node11);
    free(node12);
    free(node13);
}