中序遍历二叉树运行代码

中序遍历是一种常见的二叉树遍历方法，它按照“左-根-右”的顺序访问每个节点。在递归形式的实现中，首先访问左子树，然后访问根节点，最后访问右子树。以下是使用Python实现的中序遍历二叉树的示例代码：

# 定义二叉树节点结构
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def inorder_traversal(root):
    if root is not None:
        # 先递归遍历左子树
        inorder_traversal(root.left)
        # 访问当前节点
        print(root.val, end=' ')
        # 再递归遍历右子树
        inorder_traversal(root.right)

# 示例用法
# 创建一个简单的二叉树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

# 调用中序遍历函数
inorder_traversal(root)

相关问题

C 语言完成 二叉树的基本操作 内容：使用二叉链表存储结构建立一棵二叉树，完成如下功能： 1.创建二叉树 2.先序遍历二叉树 3.中序遍历二叉树 4.后序遍历二叉树 5.求二叉树深度 6.求二叉树叶子结点个数。代码的输入和运行结果

C语言可以使用二叉链表存储结构来建立一棵二叉树，并完成以下基本操作：

1. 创建二叉树：
可以通过递归的方式创建二叉树，每次递归创建一个节点，并设置其左右子节点。

2. 先序遍历二叉树：
先序遍历的顺序是先访问根节点，然后递归遍历左子树，最后递归遍历右子树。

3. 中序遍历二叉树：
中序遍历的顺序是先递归遍历左子树，然后访问根节点，最后递归遍历右子树。

4. 后序遍历二叉树：
后序遍历的顺序是先递归遍历左子树，然后递归遍历右子树，最后访问根节点。

5. 求二叉树深度：
可以通过递归的方式求解二叉树的深度，每次递归时比较左右子树的深度，取较大值并加1。

6. 求二叉树叶子结点个数：
可以通过递归的方式求解二叉树的叶子结点个数，每次递归时判断当前节点是否为叶子节点，如果是则计数加1，否则递归遍历左右子树。

下面是一个示例代码，实现了以上功能：

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

// 二叉树节点结构
typedef struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// 创建二叉树
TreeNode* createBinaryTree() {
    int data;
    scanf("%d", &data);
    if (data == -1) {  // 输入-1表示空节点
        return NULL;
    }
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->data = data;
    node->left = createBinaryTree();
    node->right = createBinaryTree();
    return node;
}

// 先序遍历二叉树
void preOrderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    printf("%d ", root->data);
    preOrderTraversal(root->left);
    preOrderTraversal(root->right);
}

// 中序遍历二叉树
void inOrderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    inOrderTraversal(root->left);
    printf("%d ", root->data);
    inOrderTraversal(root->right);
}

// 后序遍历二叉树
void postOrderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    postOrderTraversal(root->left);
    postOrderTraversal(root->right);
    printf("%d ", root->data);
}

// 求二叉树深度
int getTreeDepth(TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    int leftDepth = getTreeDepth(root->left);
    int rightDepth = getTreeDepth(root->right);
    return (leftDepth > rightDepth ? leftDepth : rightDepth) + 1;
}

// 求二叉树叶子结点个数
int getLeafNodeCount(TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    if (root->left == NULL && root->right == NULL) {
        return 1;
    }
    return getLeafNodeCount(root->left) + getLeafNodeCount(root->right);
}

int main() {
    printf("请输入二叉树的节点数据，-1表示空节点：\n");
    TreeNode* root = createBinaryTree();

    printf("先序遍历结果：");
    preOrderTraversal(root);
    printf("\n");

    printf("中序遍历结果：");
    inOrderTraversal(root);
    printf("\n");

    printf("后序遍历结果：");
    postOrderTraversal(root);
    printf("\n");

    int depth = getTreeDepth(root);
    printf("二叉树深度：%d\n", depth);

    int leafNodeCount = getLeafNodeCount(root);
    printf("二叉树叶子结点个数：%d\n", leafNodeCount);

    return 0;
}

请注意，以上代码只是一个示例，实际使用时可能需要根据具体需求进行修改。另外，输入和运行结果会根据具体的输入数据而有所不同。

使用数据结构知识用C语言编写完整的程序完成以下功能：1.创建二叉树 2.先序遍历二叉树 3.中序遍历二叉树 4.后序遍历二叉树 5.求二叉树深度 6.求二叉树叶子结点个数

下面是使用数据结构知识用C语言编写完整程序，实现二叉树的创建、遍历、深度和叶子节点个数的功能。请参考代码：

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

// 定义二叉树结点结构体
typedef struct TreeNode {
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

// 创建二叉树
TreeNode *create_tree() {
    int value;
    scanf("%d", &value);
    if (value == -1) { // 结束标志
        return NULL;
    }
    TreeNode *node = (TreeNode *)malloc(sizeof(TreeNode));
    node->data = value;
    node->left = create_tree();
    node->right = create_tree();
    return node;
}

// 先序遍历二叉树
void preorder_traversal(TreeNode *node) {
    if (node == NULL) {
        return;
    }
    printf("%d ", node->data);
    preorder_traversal(node->left);
    preorder_traversal(node->right);
}

// 中序遍历二叉树
void inorder_traversal(TreeNode *node) {
    if (node == NULL) {
        return;
    }
    inorder_traversal(node->left);
    printf("%d ", node->data);
    inorder_traversal(node->right);
}

// 后序遍历二叉树
void postorder_traversal(TreeNode *node) {
    if (node == NULL) {
        return;
    }
    postorder_traversal(node->left);
    postorder_traversal(node->right);
    printf("%d ", node->data);
}

// 求二叉树深度
int tree_depth(TreeNode *node) {
    if (node == NULL) {
        return 0;
    }
    int left_depth = tree_depth(node->left);
    int right_depth = tree_depth(node->right);
    return left_depth > right_depth ? left_depth + 1 : right_depth + 1;
}

// 求二叉树叶子结点个数
int leaf_count(TreeNode *node) {
    if (node == NULL) {
        return 0;
    }
    if (node->left == NULL && node->right == NULL) {
        return 1;
    }
    return leaf_count(node->left) + leaf_count(node->right);
}

int main() {
    // 创建二叉树
    printf("请输入二叉树每个节点的值，-1表示此节点为空：\n");
    TreeNode *root = create_tree();

    // 先序遍历二叉树
    printf("先序遍历二叉树：\n");
    preorder_traversal(root);
    printf("\n");

    // 中序遍历二叉树
    printf("中序遍历二叉树：\n");
    inorder_traversal(root);
    printf("\n");

    // 后序遍历二叉树
    printf("后序遍历二叉树：\n");
    postorder_traversal(root);
    printf("\n");

    // 求二叉树深度
    printf("二叉树深度为：%d\n", tree_depth(root));

    // 求二叉树叶子结点个数
    printf("二叉树叶子结点个数为：%d\n", leaf_count(root));

    return 0;
}

程序运行结果：

请输入二叉树每个节点的值，-1表示此节点为空：
1 2 -1 -1 3 4 -1 -1 5 -1 -1
先序遍历二叉树：
1 2 3 4 5 
中序遍历二叉树：
2 1 4 3 5 
后序遍历二叉树：
2 4 5 3 1 
二叉树深度为：3
二叉树叶子结点个数为：3