第一部分：基本含义

“每个节点最多有两个孩子” 的家族树：

• 每个节点最多有 左子节点 和 右子节点 两个分支。
• 最顶端的节点叫 根节点，是整棵树的起点。
• 没有子节点的节点叫 叶子节点，在树的最底层。

    1  <-- 根节点
   / \
  2   3 <-- 子节点
 / \
4   5 <-- 叶子节点

第二部分：二叉树的类型

1. 满二叉树除了叶子节点，每个节点都有左、右两个子节点，且所有叶子都在同一层。

2. 完全二叉树除了最后一层，其他层的节点数都达到最大值，且最后一层的节点都靠左排列。

3. 二叉搜索树（BST）左子树的所有节点值都小于根节点，右子树的所有节点值都大于根节点。你截图里的「验证二叉搜索树」「将有序数组转换为二叉搜索树」都是这类题。

4. 平衡二叉树左右两个子树的高度差不超过 1，能保证查询效率。

第三部分：二叉树的遍历

• 遍历按一定顺序访问所有节点，常见的有：

  • 中序遍历：左 → 根 → 右（比如例子里是 4→2→5→1→3）
  • 层序遍历：按层次从上到下、从左到右访问（比如例子里是 1→2→3→4→5）

• 深度 / 高度

  • 节点的深度：从根到该节点的路径长度。
  • 树的高度：从根到最远叶子节点的路径长度（对应「二叉树的最大深度」）。

• 翻转二叉树把每个节点的左、右子节点交换位置，比如上面的例子翻转后：

      1
     / \
    3   2
       / \
      5   4
  

• 对称二叉树树的左子树和右子树是镜像对称的，比如：

      1
     / \
    2   2
   / \ / \
  3  4 4  3

第四部分：二叉树的基本python代码实现

（1）二叉树节点定义

二叉树的最小单元是节点，每个节点包含「值」、「左子节点引用」、「右子节点引用」，这是所有操作的基础，代码超简单：

# 定义二叉树节点类
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val  # 节点存储的值
        self.left = left  # 左子节点（引用/指针）
        self.right = right  # 右子节点（引用/指针）

理解：就像每个节点有一个值，还有两个 “指针”，分别指向左边和右边的孩子（没有孩子则为None）。

（2）构建一棵示例二叉树

先搭一棵直观的二叉树，后续所有操作都基于这棵树，方便对照结果理解：

    1        根节点
   / \
  2   3      第二层节点
 / \
4   5        第三层节点（叶子节点）

构建代码：从最底层叶子节点开始，往上拼接即可

# 构建示例二叉树
# 叶子节点
node4 = TreeNode(4)
node5 = TreeNode(5)
node3 = TreeNode(3)
# 第二层节点
node2 = TreeNode(2, node4, node5)  # node2的左是node4，右是node5
# 根节点
root = TreeNode(1, node2, node3)  # 根节点left=node2，right=node3

完整代码如下：

def print_tree(root):
    """
    直观打印二叉树结构（根在上，带斜线连接）
    """
    if not root:
        print("Empty tree")
        return

    # 计算树的高度
    def get_height(node):
        if not node:
            return 0
        return 1 + max(get_height(node.left), get_height(node.right))

    height = get_height(root)
    width = 2 ** height - 1  # 网格总宽度

    # 初始化网格（行数 = 2*height - 1，包含连接线行）
    # 偶数行：节点值；奇数行：连接线
    grid = [[' ' for _ in range(width)] for _ in range(2 * height - 1)]

    # 递归放置节点和连接线
    def place_nodes(node, level, left, right):
        if not node:
            return

        row = 2 * level  # 节点所在行（偶数行）
        col = (left + right) // 2  # 水平居中位置

        # 放置节点值（支持多位数）
        val_str = str(node.val)
        start = col - len(val_str) // 2
        for i, char in enumerate(val_str):
            if 0 <= start + i < width:
                grid[row][start + i] = char

        # 递归处理子节点
        if node.left:
            left_col = (left + col - 1) // 2
            place_nodes(node.left, level + 1, left, col - 1)
            # 添加左连接线 '/'
            if level < height - 1:
                grid[row + 1][col - 1] = '/'

        if node.right:
            right_col = (col + 1 + right) // 2
            place_nodes(node.right, level + 1, col + 1, right)
            # 添加右连接线 '\'
            if level < height - 1:
                grid[row + 1][col + 1] = '\\'

    place_nodes(root, 0, 0, width - 1)

    # 打印网格（跳过全空行）
    for row in grid:
        line = ''.join(row).rstrip()
        if line:
            print(line)
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val  # 节点存储的值
        self.left = left  # 左子节点（引用/指针）
        self.right = right  # 右子节点（引用/指针）
# 构建示例二叉树
# 叶子节点
node4 = TreeNode(4)
node5 = TreeNode(5)
node3 = TreeNode(3)
# 第二层节点
node2 = TreeNode(2, node4, node5)  # node2的左是node4，右是node5
# 根节点
root = TreeNode(1, node2, node3)  # 根节点left=node2，right=node3



print("示例二叉树结构：")
print_tree(root)