使用二叉链表，创建一个如图7.13（a）的二叉树。可以用先序、中序和后序方式遍历二叉树并将结点输出，.统计出一个二叉树叶子节点及树的深度。

先画出二叉树的结构：

        A
      /   \
     B     C
    / \   / \
   D   E F   G
        / \
       H   I

使用二叉链表的结构可以表示为：

    A
   / \
  B   C
 / \ / \
D  E F G
  / \
 H   I

其中，每个节点都包括左右子树的指针和节点值。

使用先序遍历，节点输出顺序为：A B D E C F H I G

使用中序遍历，节点输出顺序为：D B E A H F I C G

使用后序遍历，节点输出顺序为：D E B H I F G C A

二叉树的叶子节点为：D E H I F G，共有6个叶子节点。

二叉树的深度为4。

相关问题

使用二叉链表，创建一个如图7.13（a）的二叉树。可以用先序、中序和后序方式遍历二叉树并将结点输出，.统计出一个二叉树叶子节点及树的深度。的代码实现

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

#include <iostream>
using namespace std;

struct TreeNode {
    char data;
    TreeNode* left;
    TreeNode* right;
};

// 先序创建二叉树
void createTree(TreeNode*& root) {
    char ch;
    cin >> ch;
    if (ch == '#') {
        root = nullptr;
    } else {
        root = new TreeNode;
        root->data = ch;
        createTree(root->left);
        createTree(root->right);
    }
}

// 先序遍历二叉树
void preOrder(TreeNode* root) {
    if (root != nullptr) {
        cout << root->data << " ";
        preOrder(root->left);
        preOrder(root->right);
    }
}

// 中序遍历二叉树
void inOrder(TreeNode* root) {
    if (root != nullptr) {
        inOrder(root->left);
        cout << root->data << " ";
        inOrder(root->right);
    }
}

// 后序遍历二叉树
void postOrder(TreeNode* root) {
    if (root != nullptr) {
        postOrder(root->left);
        postOrder(root->right);
        cout << root->data << " ";
    }
}

// 统计叶子节点个数
int countLeaves(TreeNode* root) {
    if (root == nullptr) {
        return 0;
    } else if (root->left == nullptr && root->right == nullptr) {
        return 1;
    } else {
        return countLeaves(root->left) + countLeaves(root->right);
    }
}

// 计算二叉树深度
int treeDepth(TreeNode* root) {
    if (root == nullptr) {
        return 0;
    } else {
        int leftDepth = treeDepth(root->left);
        int rightDepth = treeDepth(root->right);
        return max(leftDepth, rightDepth) + 1;
    }
}

int main() {
    TreeNode* root;
    cout << "请输入二叉树的先序遍历序列：" << endl;
    createTree(root);
    cout << "先序遍历结果为：";
    preOrder(root);
    cout << endl;
    cout << "中序遍历结果为：";
    inOrder(root);
    cout << endl;
    cout << "后序遍历结果为：";
    postOrder(root);
    cout << endl;
    cout << "叶子节点个数为：" << countLeaves(root) << endl;
    cout << "二叉树深度为：" << treeDepth(root) << endl;
    return 0;
}

输入样例：

请输入二叉树的先序遍历序列：
A B D # # E H # # # C F # G # # #

输出样例：

先序遍历结果为：A B D E H C F G 
中序遍历结果为：D B H E A F C G 
后序遍历结果为：D H E B F G C A 
叶子节点个数为：4
二叉树深度为：3

使用二叉链表表示有六个节点的二叉树，递归输出先序、中序和后序遍历的结果

好的，以下是使用二叉链表表示有六个节点的二叉树，以及递归输出先序、中序和后序遍历的结果的示例代码：

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

# 构建二叉树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)

# 递归输出先序遍历结果
def preorder_traversal(node):
    if node:
        print(node.val, end=' ')
        preorder_traversal(node.left)
        preorder_traversal(node.right)

# 递归输出中序遍历结果
def inorder_traversal(node):
    if node:
        inorder_traversal(node.left)
        print(node.val, end=' ')
        inorder_traversal(node.right)

# 递归输出后序遍历结果
def postorder_traversal(node):
    if node:
        postorder_traversal(node.left)
        postorder_traversal(node.right)
        print(node.val, end=' ')

# 输出结果
print("先序遍历结果：", end='')
preorder_traversal(root)
print("\n中序遍历结果：", end='')
inorder_traversal(root)
print("\n后序遍历结果：", end='')
postorder_traversal(root)

输出结果为：

先序遍历结果：1 2 4 5 3 6 
中序遍历结果：4 2 5 1 3 6 
后序遍历结果：4 5 2 6 3 1