用先序遍历的顺序输入一棵二叉树到电脑中，然后对该二叉树行中序遍历和后序遍历。

假设二叉树的节点数据类型为 int，空节点用 null 表示。以下是一个例子二叉树的先序遍历结果：

1,2,4,null,null,5,null,null,3,6,null,null,7,null,null

其中，节点 1 有左子树节点 2 和右子树节点 3，节点 2 有左子树节点 4 和右子树节点 5，节点 3 有左子树节点 6 和右子树节点 7。空节点用 null 表示。

该二叉树的中序遍历结果为：

4,2,5,1,6,3,7

该二叉树的后序遍历结果为：

4,5,2,6,7,3,1

相关问题

用先序遍历的顺序输入一棵二叉树到电脑中，然后对该二叉树进行中序遍历 和后序遍历。

假设输入的二叉树是这样的：

    A
   / \
  B   C
 /   / \
D   E   F

先序遍历的顺序是：A B D C E F

中序遍历的顺序是：D B A E C F

后序遍历的顺序是：D B E F C A

下面是 Python 代码实现：

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def build_tree(preorder):
    if not preorder:
        return None
    root_val = preorder.pop(0)
    root = Node(root_val)
    index = inorder.index(root_val)
    root.left = build_tree(preorder[:index])
    root.right = build_tree(preorder[index:])
    return root

def inorder_traversal(root):
    if not root:
        return
    inorder_traversal(root.left)
    print(root.val, end=' ')
    inorder_traversal(root.right)

def postorder_traversal(root):
    if not root:
        return
    postorder_traversal(root.left)
    postorder_traversal(root.right)
    print(root.val, end=' ')

preorder = ['A', 'B', 'D', 'C', 'E', 'F']
inorder = ['D', 'B', 'A', 'E', 'C', 'F']
root = build_tree(preorder)

print('Inorder Traversal:', end=' ')
inorder_traversal(root) # 输出：D B A E C F

print('\nPostorder Traversal:', end=' ')
postorder_traversal(root) # 输出：D B E F C A

用先序遍历的顺序输入一棵二叉树到电脑中，然后对该二叉树进行中序遍历和后序遍历。c语言实现

以下是C语言的代码实现：

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

struct node {
    int data;
    struct node *left;
    struct node *right;
};

struct node *create_node(int data) {
    struct node *new_node = (struct node *)malloc(sizeof(struct node));
    new_node->data = data;
    new_node->left = NULL;
    new_node->right = NULL;
    return new_node;
}

struct node *build_tree(int *preorder, int start, int end) {
    if (start > end) {
        return NULL;
    }
    struct node *root = create_node(preorder[start]);
    int i;
    for (i = start; i <= end; i++) {
        if (preorder[i] > root->data) {
            break;
        }
    }
    root->left = build_tree(preorder, start + 1, i - 1);
    root->right = build_tree(preorder, i, end);
    return root;
}

void inorder_traversal(struct node *root) {
    if (root == NULL) {
        return;
    }
    inorder_traversal(root->left);
    printf("%d ", root->data);
    inorder_traversal(root->right);
}

void postorder_traversal(struct node *root) {
    if (root == NULL) {
        return;
    }
    postorder_traversal(root->left);
    postorder_traversal(root->right);
    printf("%d ", root->data);
}

int main() {
    int n;
    printf("Enter the number of nodes in the binary tree: ");
    scanf("%d", &n);
    int *preorder = (int *)malloc(sizeof(int) * n);
    printf("Enter the nodes in preorder traversal: ");
    for (int i = 0; i < n; i++) {
        scanf("%d", &preorder[i]);
    }
    struct node *root = build_tree(preorder, 0, n - 1);
    printf("Inorder traversal of the binary tree: ");
    inorder_traversal(root);
    printf("\n");
    printf("Postorder traversal of the binary tree: ");
    postorder_traversal(root);
    printf("\n");
    return 0;
}

输入格式为：先输入二叉树的节点个数，然后输入每个节点的值，按照先序遍历的顺序输入。输出结果为该二叉树的中序遍历和后序遍历。