【LeetCode刷题】二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

• 树中节点数目在范围 [0, 2000] 内
• -1000 <= Node.val <= 1000

解题思路

层序遍历（广度优先搜索，BFS）的核心是按层处理节点，用队列维护当前层的所有节点，步骤如下：

1. 初始化：若树为空，直接返回空列表；否则将根节点加入队列。
2. 逐层处理 ：每次获取当前队列的长度（即当前层的节点数），遍历这些节点：
   • 取出节点，将值加入当前层的子列表；
   • 若节点有左 / 右子节点，将子节点加入队列（用于下一层处理）。
3. 收集结果：将当前层的子列表加入最终结果，直到队列为空。

示例验证（输入root = [3,9,20,null,null,15,7]）

• 初始队列：[3]，层大小 = 1 → 处理节点 3，当前层[3]，加入子节点 9、20 → 队列变为[9,20]。
• 下一层：层大小 = 2 → 处理节点 9、20，当前层[9,20]，加入子节点 15、7 → 队列变为[15,7]。
• 下一层：层大小 = 2 → 处理节点 15、7，当前层[15,7]，无子节点 → 队列为空。
• 最终结果：[[3], [9,20], [15,7]]，与示例输出完全一致。

算法复杂度

• 时间复杂度：O(n)（每个节点入队和出队各一次，共处理n个节点）；
• 空间复杂度：O(n)（队列最多存储一层的节点，最坏情况为完全二叉树的最后一层，节点数约为n/2）。

Python代码

from typing import Optional, List, Deque
from collections import deque


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


class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        # 用队列保存当前层的节点
        queue: Deque[TreeNode] = deque([root])
        result = []
        while queue:
            # 当前层的节点数量
            level_size = len(queue)
            current_level = []
            for _ in range(level_size):
                node = queue.popleft()
                current_level.append(node.val)
                # 左子节点非空则加入队列
                if node.left:
                    queue.append(node.left)
                # 右子节点非空则加入队列
                if node.right:
                    queue.append(node.right)
            result.append(current_level)
        return result


# ---------------------- 辅助函数 ----------------------
def build_tree(nums: List[Optional[int]]) -> Optional[TreeNode]:
    """层序构建二叉树（适配LeetCode数组表示法）"""
    if not nums or nums[0] is None:
        return None
    root = TreeNode(nums[0])
    q: Deque[TreeNode] = deque([root])
    idx = 1
    while q and idx < len(nums):
        cur = q.popleft()
        if nums[idx] is not None:
            cur.left = TreeNode(nums[idx])
            q.append(cur.left)
        idx += 1
        if idx < len(nums) and nums[idx] is not None:
            cur.right = TreeNode(nums[idx])
            q.append(cur.right)
        idx += 1
    return root


# ---------------------- 测试用例验证 ----------------------
if __name__ == "__main__":
    sol = Solution()
    # 示例1输入：root = [3,9,20,null,null,15,7]
    root1 = build_tree([3, 9, 20, None, None, 15, 7])
    print(f"层序遍历结果：{sol.levelOrder(root1)}")  # 输出 [[3], [9, 20], [15, 7]]

    # 示例2输入：root = [1]
    root2 = build_tree([1])
    print(f"层序遍历结果：{sol.levelOrder(root2)}")  # 输出 [[1]]

    # 示例3输入：空树
    root3 = build_tree([])
    print(f"层序遍历结果：{sol.levelOrder(root3)}")  # 输出 []

LeetCode刷题

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        # 用队列保存当前层的节点
        queue: Deque[TreeNode] = deque([root])
        result = []
        while queue:
            # 当前层的节点数量
            level_size = len(queue)
            current_level = []
            for _ in range(level_size):
                node = queue.popleft()
                current_level.append(node.val)
                # 左子节点非空则加入队列
                if node.left:
                    queue.append(node.left)
                # 右子节点非空则加入队列
                if node.right:
                    queue.append(node.right)
            result.append(current_level)
        return result

程序运行截图展示

总结

本文介绍了二叉树的层序遍历（BFS）实现方法。通过队列按层处理节点，首先将根节点入队，然后逐层遍历：取出当前层节点并记录值，将其子节点入队用于下一层处理。时间复杂度为O(n)，空间复杂度为O(n)。提供了Python实现代码，包含TreeNode类定义、层序遍历函数和测试用例，验证了示例输入的正确输出。该方法适用于LeetCode相关题目，能有效实现二叉树的逐层遍历。