给你二叉树的根节点 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）的核心是按层处理节点，用队列维护当前层的所有节点，步骤如下：
- 初始化：若树为空，直接返回空列表；否则将根节点加入队列。
- 逐层处理 ：每次获取当前队列的长度（即当前层的节点数），遍历这些节点：
- 取出节点，将值加入当前层的子列表；
- 若节点有左 / 右子节点，将子节点加入队列（用于下一层处理）。
- 收集结果：将当前层的子列表加入最终结果，直到队列为空。
示例验证（输入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代码
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刷题
python
# 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相关题目，能有效实现二叉树的逐层遍历。