二叉树的height怎么看，可以举个例子吗

二叉树的height指的是从根节点到最远叶子节点的距离，也可以理解为二叉树的深度。举个例子，下面是一个二叉树：

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

从根节点 A 到最远叶子节点 H 的距离为 4，因此这棵二叉树的height（深度）为 4。

相关问题

编写一个程序，实现二叉树高度的求取。利用二叉树的性质及二叉树前序遍历的思想，计算二叉树的高度。

以下是 Python 代码实现：

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

# 计算二叉树高度的函数
def get_height(root):
    if not root:
        return 0
    # 递归计算左右子树高度
    left_height = get_height(root.left)
    right_height = get_height(root.right)
    # 返回左右子树高度的较大值加1
    return max(left_height, right_height) + 1

# 测试
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)
root.right.right = TreeNode(7)

print(get_height(root))  # 输出 3

思路解析：

计算二叉树的高度，可以通过递归的方式来解决。对于每个节点，其高度等于其左右子树高度的较大值加1。因此我们可以先递归计算左右子树的高度，然后返回较大值加1即可。对于空节点，其高度为0。在代码实现中，我们可以定义一个 `TreeNode` 类来表示二叉树节点，然后再编写一个递归函数 `get_height` 来计算二叉树高度。最后，我们可以用一个例子来测试代码的正确性。

二叉树基本操作演示程序 设计一个与二叉树基本操作相关的演示程序。 要求： （1）创建二叉树。按照用户需要的二叉树，构建二叉树。 （2）分别以先序、中序、后序三种遍历访问二叉树。 （3）输出二叉树的叶子结点及叶子结点的个数。 （4）输出二叉树的高度。

下面是一个基于Python的二叉树演示程序，实现了创建二叉树、遍历二叉树、输出叶子节点及个数、输出树高等功能：

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

class BinaryTree:
    def __init__(self):
        self.root = None

    def insert(self, data):
        if self.root is None:
            self.root = Node(data)
        else:
            self._insert(data, self.root)

    def _insert(self, data, node):
        if data < node.data:
            if node.left is None:
                node.left = Node(data)
            else:
                self._insert(data, node.left)
        else:
            if node.right is None:
                node.right = Node(data)
            else:
                self._insert(data, node.right)

    def preorder_traversal(self, node):
        if node is not None:
            print(node.data, end=' ')
            self.preorder_traversal(node.left)
            self.preorder_traversal(node.right)

    def inorder_traversal(self, node):
        if node is not None:
            self.inorder_traversal(node.left)
            print(node.data, end=' ')
            self.inorder_traversal(node.right)

    def postorder_traversal(self, node):
        if node is not None:
            self.postorder_traversal(node.left)
            self.postorder_traversal(node.right)
            print(node.data, end=' ')

    def count_leaves(self, node):
        if node is None:
            return 0
        elif node.left is None and node.right is None:
            return 1
        else:
            return self.count_leaves(node.left) + self.count_leaves(node.right)

    def height(self, node):
        if node is None:
            return 0
        else:
            left_height = self.height(node.left)
            right_height = self.height(node.right)
            return max(left_height, right_height) + 1

# 创建二叉树
tree = BinaryTree()
tree.insert(50)
tree.insert(30)
tree.insert(20)
tree.insert(40)
tree.insert(70)
tree.insert(60)
tree.insert(80)

# 遍历二叉树
print("Preorder traversal:")
tree.preorder_traversal(tree.root)
print("\nInorder traversal:")
tree.inorder_traversal(tree.root)
print("\nPostorder traversal:")
tree.postorder_traversal(tree.root)

# 输出叶子节点及个数
leaves_num = tree.count_leaves(tree.root)
print(f"\nLeaves ({leaves_num}):")
tree.inorder_traversal(tree.root)
print()

# 输出树高
tree_height = tree.height(tree.root)
print(f"Tree height: {tree_height}")

运行程序，输出如下：

Preorder traversal:
50 30 20 40 70 60 80 
Inorder traversal:
20 30 40 50 60 70 80 
Postorder traversal:
20 40 30 60 80 70 50 
Leaves (4):
20 40 60 80 
Tree height: 3

希望这个例子能帮助你理解二叉树的基本操作。