/**
 * Definition for a binary tree node.
 * 
 * public class TreeNode {
 *     int val;              // 节点存储的整数值
 *     TreeNode left;        // 指向左子节点的引用（指针）
 *     TreeNode right;       // 指向右子节点的引用（指针）
 *     
 *     // 默认构造函数：创建一个空节点（val 默认为 0）
 *     TreeNode() {}
 *     
 *     // 构造函数：根据给定的值创建一个节点，左右子节点默认为 null
 *     TreeNode(int val) { 
 *         this.val = val; 
 *     }
 *     
 *     // 构造函数：根据给定的值和左右子节点创建一个完整节点
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

class Solution {
    /**
     * 计算二叉树的最大深度（也称为高度）。
     * 
     * 二叉树的最大深度是从根节点到最远叶子节点的最长路径上的节点数。
     * 使用层序遍历（广度优先搜索，BFS）的方式，逐层向下遍历，
     * 每遍历一层，深度加一，直到所有层都处理完毕。
     * 
     * 示例：
     * 给定二叉树：
     *       3
     *      / \
     *     9   20
     *        /  \
     *       15   7
     * 返回最大深度：3
     * 
     * 解释：
     * 第0层：[3]        -> 深度 = 1
     * 第1层：[9, 20]     -> 深度 = 2
     * 第2层：[15, 7]     -> 深度 = 3
     * 
     * @param root 二叉树的根节点
     * @return 返回二叉树的最大深度（整数）
     */
    public int maxDepth(TreeNode root) {
        // 创建一个队列用于实现广度优先搜索（BFS）
        // 队列中存储待处理的树节点
        Queue<TreeNode> queue = new LinkedList<>();
        
        // 如果根节点为空，说明树为空，深度为 0
        if (root == null) return 0;
        
        // 将根节点加入队列，作为遍历的起点
        queue.offer(root);

        // 记录当前树的深度，初始为 0
        int depth = 0;

        // 当队列不为空时，说明还有节点未处理（即还有层未遍历完）
        while (!queue.isEmpty()) {
            // 记录当前层的节点数量
            // 这个值决定了内层循环需要处理多少个节点
            int len = queue.size();
            
            // 每进入一层，深度加一
            depth++;

            // 遍历当前层的所有节点（共 len 个）
            for (int i = 0; i < len; i++) {
                // 从队列头部取出一个节点进行处理
                TreeNode temp = queue.poll();
                
                // 如果当前节点有左子节点，则将其加入队列，供下一层处理
                if (temp.left != null) {
                    queue.offer(temp.left);
                }
                
                // 如果当前节点有右子节点，则将其加入队列，供下一层处理
                if (temp.right != null) {
                    queue.offer(temp.right);
                }
            }
            // 当前层的所有节点处理完毕
            // 队列中现在存储的是下一层的所有节点（如果有）
        }

        // 所有层遍历结束，返回最终的深度
        return depth;
    }
}