二叉树的层序遍历

给你二叉树的根节点 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）的策略。具体来说，我们将使用一个队列来实现这一点，以便逐层访问树的节点。

核心就是遍历根节点的时候把根节点的子节点放入队列实现对数的遍历并将每一层的所有数字放入数组中，将本层全部节点打印到一行，并将下一层全部节点加入队列，以此类推，即可分为多行打印。

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;



/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
// 定义二叉树节点
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

public class BinaryTreeLevelOrderTraversal {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result; // 如果根节点为空，返回空结果
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root); // 将根节点放入队列

        while (!queue.isEmpty()) {
            int levelSize = queue.size(); // 当前层节点数量
            List<Integer> currentLevel = new ArrayList<>(); // 当前层节点值

            for (int i = 0; i < levelSize; i++) {
                TreeNode currentNode = queue.poll(); // 从队列中取出当前节点
                currentLevel.add(currentNode.val); // 添加当前节点值到当前层列表

                // 如果左子节点存在，放入队列
                if (currentNode.left != null) {
                    queue.add(currentNode.left);
                }
                // 如果右子节点存在，放入队列
                if (currentNode.right != null) {
                    queue.add(currentNode.right);
                }
            }

            result.add(currentLevel); // 将当前层结果添加到最终结果中
        }

        return result; // 返回最终的层序遍历结果
    }

    public static void main(String[] args) {
        // 构建示例树：3, 9, 20, null, null, 15, 7
        TreeNode root = new TreeNode(3);
        root.left = new TreeNode(9);
        root.right = new TreeNode(20);
        root.right.left = new TreeNode(15);
        root.right.right = new TreeNode(7);
        
        // 实例化类和调用层序遍历方法
        BinaryTreeLevelOrderTraversal traversal = new BinaryTreeLevelOrderTraversal();
        List<List<Integer>> result = traversal.levelOrder(root);
        
        // 输出结果
        System.out.println(result); // 输出: [[3], [9, 20], [15, 7]]
    }
}

1. TreeNode 类:

   • 定义了二叉树的节点，包括节点值 val，左子节点 left 和右子节点 right。

2. levelOrder 方法:

   • 接受根节点 root 作为参数，返回节点值的层序遍历。
   • 使用 result 列表存储每一层的节点值。
   • 使用队列（Queue）来实现层序遍历，首先将根节点添加到队列中。
   • 进入一个循环，当队列不为空时，逐层读取节点：
     • 记录当前层的节点数量。
     • 使用内层循环遍历当前层所有节点，取出每个节点并将它的值添加到当前层列表中。
     • 将当前节点的子节点（如果存在）添加到队列中，为下一层做准备。
   • 当前层处理完成后，将当前层的结果添加到 result。

时间与空间复杂度

• 时间复杂度: O(N)，其中 N 是树中节点的数量。每个节点都被访问一次。
• 空间复杂度: O(N)，最坏情况下，队列中可能存储所有叶子节点。