【LeetCodehot100】 T543：二叉树的直径 T102:二叉树的层序遍历

T543：二叉树的直径

题目要求：

给你一棵二叉树的根节点，返回该树的直径。

二叉树的直径是指树中任意两个节点之间最长路径的长度。这条路径可能经过也可能不经过根节点 root 。

两节点之间路径的长度由它们之间边数表示。

题目理解

什么是直径

二叉树中任意两个节点之间的最长路径（边数）

核心思路

路径问题 → 转化为深度问题

对于任意一个节点：
经过该节点的最长路径 = 左子树深度 + 右子树深度

所有我们需要遍历所有节点，找出最大值。

代码实现

java 复制代码

class Solution {
    int max = 0;

    public int diameterOfBinaryTree(TreeNode root) {
        depth(root);
        return max;
    }

    private int depth(TreeNode node) {
        if (node == null) return 0;

        int left = depth(node.left);
        int right = depth(node.right);

        // 更新直径
        max = Math.max(max, left + right);

        // 返回深度
        return Math.max(left, right) + 1;
    }
}

题目感悟

一开始看depth（）方法特别蒙，没看懂是什么意思。现在解释一下。

depth是递归方法。当depth（node.left）中node.left不是最底层节点时，depth会自动先计算node.left的左子树，直到左子树为最下层节点。

T102:二叉树的层序遍历

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

题目本质：

按层，一层一层，从左到右输出节点（BFS遍历）

核心思路

层序遍历 = BFS（广度优先搜索）

和之前的递归（DFS）不同

代码实现

java 复制代码

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();

        // 边界条件
        if (root == null) return res;

        // 队列：用于按层遍历
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root); // 根节点入队

        // 开始 BFS
        while (!queue.isEmpty()) {

            int size = queue.size(); // 当前层节点个数
            List<Integer> level = new ArrayList<>();

            // 遍历当前层
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll(); // 取出队头

                level.add(node.val); // 收集当前节点

                // 把下一层节点加入队列
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }

            // 当前层处理完，加入结果
            res.add(level);
        }

        return res;
    }
}

本题感悟

注意队列与集合level的区别，queue用于保存"下一层要处理的节点"

集合用于收集当前节点。

区分BFS和DFS：

方式	特点
DFS	一条路走到底（递归）
BFS	一层一层走（队列）