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

Luna_M

已于 2024-02-01 21:28:25 修改

阅读量473

点赞数 12

分类专栏： Python Coding with ChatGPT 文章标签： python 宽度优先开发语言 leetcode 算法数据结构

于 2024-01-30 15:55:18 首次发布

本文链接：https://blog.csdn.net/baidu_33000721/article/details/135934233

版权

Python Coding with ChatGPT 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

本文介绍了二叉树的层序遍历方法及其在Python中的实现，包括使用队列的数据结构，以及如何处理填充每个节点的下一个右侧节点指针和计算最大/最小深度。同时涵盖了相关算法题目和深度优先搜索的讲解。

摘要由CSDN通过智能技术生成

Key Points

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

视频讲解

二叉树的广度优先搜索

重点分析

层序遍历：

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))