python coding with ChatGPT 打卡第14天| 二叉树的广度优先遍历

相关推荐
python coding with ChatGPT 打卡第12天| 二叉树：理论基础
python coding with ChatGPT 打卡第13天| 二叉树的深度优先遍历

Key Points

二叉树的层序遍历是指按照树的层次，从上到下、从左到右依次访问树中的每个节点。为了实现层序遍历，通常使用队列作为辅助数据结构。队列能够帮助我们按照树的层次顺序访问每个节点。

视频讲解

二叉树的广度优先搜索

相关题目

102. 二叉树的层序遍历
107. 二叉树的层次遍历II
199. 二叉树的右视图
637. 二叉树的层平均值
429. N叉树的层序遍历
515. 在每个树行中找最大值

116. 填充每个节点的下一个右侧节点指针
117. 填充每个节点的下一个右侧节点指针II

104. 二叉树的最大深度
559. n叉树的最大深度
111. 二叉树的最小深度

重点分析

层序遍历：

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

def levelOrder(root):
    if not root:
        return []

    queue = [root]
    result = []

    while queue:
        level_size = len(queue)  # 当前层的节点数量
        level_nodes = []  # 存储当前层的节点值

        for _ in range(level_size):
            node = queue.pop(0)  # 弹出当前层的一个节点
            level_nodes.append(node.val)  # 访问该节点

            # 将节点的左右子节点加入队列
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

        result.append(level_nodes)

    return result

填充每个节点的下一个右侧节点指针：

def connect(root):
    if not root:
        return None   # 注意这里不能是[]

    queue = [root]

    while queue:
        size = len(queue)
        for i in range(size):
            node = queue.pop(0)
            if i < size - 1:
                node.next = queue[0]

            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

    return root

最大深度：
法1 层序遍历法：

def maxDepth(root):
    res = 0
    if not root:
        return res
    queue_record = [root]

    while queue_record:
        level_size = len(queue_record)
        for _ in range(level_size):
            node = queue_record.pop(0)
            if node.left:
                queue_record.append(node.left)
            if node.right:
                queue_record.append(node.right)

        res += 1

    return res

法2 递归法：

def maxDepth(root):
    if not root:
        return 0

    left_depth = maxDepth(root.left)
    right_depth = maxDepth(root.right)

    return max(left_depth, right_depth) + 1

最小深度：
法1 层序遍历法：

迭代方法可以使用层序遍历，一旦我们到达了一个叶子节点，立即返回当前深度。

def minDepth(root):
    if not root:
        return 0

    queue = [(root, 1)]  # 节点和其深度
    while queue:
        node, depth = queue.pop(0)  # 从队列前端弹出
        if not node.left and not node.right:
            return depth  # 找到叶子节点
        if node.left:
            queue.append((node.left, depth + 1))  # 将左子节点加入队列
        if node.right:
            queue.append((node.right, depth + 1))  # 将右子节点加入队列

    return depth

法2 递归法：

def minDepth(root):
    if not root:
        return 0
    if not root.left and not root.right:
        return 1
    if not root.left:
        return 1 + minDepth(root.right)
    if not root.right:
        return 1 + minDepth(root.left)

    return 1 + min(minDepth(root.left), minDepth(root.right))

在这个递归方法中，我们考虑了四种情况：

1. 节点不存在（root 为空），返回深度 0。
2. 节点是叶子节点（没有左右子节点），返回深度 1。
3. 节点只有一个子节点，返回该子节点的深度加 1。
4. 节点有两个子节点，返回两个子节点深度的最小值加 1。