LeetCode每日一题20220817-题解-层数最深叶子节点的和

1302. 层数最深叶子节点的和

本题为 2022-08-17 每日一题

难度：【中等】

题目链接：https://leetcode.cn/problems/deepest-leaves-sum/

---

题目

给你一棵二叉树的根节点 root ，请你返回 层数最深的叶子节点的和 。

示例1：

输入：root = [1,2,3,4,5,null,6,7,null,null,null,null,8]
输出：15

示例2：

输入：root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]
输出：19

---

题解

思路一：队列/BFS

看到题目，最直接的想法应该是将题目抽象成：分层输出一个二叉树 -> 分层且只输出最后一层二叉树 -> 分层且只获取并计算最后一层二叉树的和。

分层输出二叉树的题目可以参考以下3题，非常经典：

剑指 Offer 32 - I. 从上到下打印二叉树

剑指 Offer 32 - II. 从上到下打印二叉树 II

剑指 Offer 32 - III. 从上到下打印二叉树 III

简单提及一下本题思路：

利用层序遍历整个二叉树，利用遍历的循环条件 - 队列的size 来判断是否当前处理的为二叉树的最后一行，如图所示：

那么就可以写出以下代码：

/**
 * 执行用时：6 ms, 在所有 Java 提交中击败了54.20%的用户
 * 内存消耗：43.8 MB, 在所有 Java 提交中击败了54.33%的用户
 */
class Solution {
    public int deepestLeavesSum(TreeNode root) {
        // 初始化cnt用于计算某一层的和
        int cnt = 0;
        // 层序遍历常用模板
        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.offer(root);
        int size = queue.size();
        // 遍历完最后一层时,size=0,所以此处用这个方法作为循环终止条件
        while (size != 0) {
            // 每层的开始都需要重置cnt
            cnt = 0;
            for (int i = 0; i < size; i++) {
                root = queue.poll();
                cnt += root.val;
                if (root.left != null) queue.offer(root.left);
                if (root.right != null) queue.offer(root.right);
            }
            // 本层遍历结束,重置size
            size = queue.size();
        }
        // 遍历完最后一层时,size为0,循环终止,直接返回cnt即可
        return cnt;
    }
}

思路二：递归/DFS

通常来说递归是比较难思考的解法之一，这里逐步引出本思路的最终流程：

本题实际上只需要最后一层的和，那么不需要使用队列进行额外的操作（使用队列就要维护队列），直接递归访问到二叉树的最后一层再相加即可。

-> 先把题目抽象成 [获取二叉树的最大深度]

-> 再重新递归整个二叉树，满足深度则相加，最终返回值

由此一来，我们需要对二叉树递归两边，大大的浪费了很多时间，而第一次递归的目的仅仅是为了获取最大深度，那么不妨把它融入到第二次递归，让每次递归的时候都自我判断是否为最大深度 -> 是最大深度则相加, 不是最大深度则记录下当前深度为最大深度,重置计数器后相加，如图所示

1. 初始化了树的最大深度depth=0, 当前层的数值的和cnt=0, 同时规定每一层的层数表示为level

2. 进入节点【6】，此时level=1，level大于depth，设置二叉树的深度为1，cnt先重置后累加

3. 进入节点【7】，此时level=2，重置并累加

4. 进入节点【2】，此时level=3，重置并累加

5. 进入节点【9】，此时level=4，重置并累加

6. 进入【7】【1】【4】···，只有当level == depth时，cnt才会累加

7. 最后得到的结果就是满足level == depth也就是最后一层的累加和

代码如下：

/**
 * 执行用时：1 ms, 在所有 Java 提交中击败了100.00%的用户
 * 内存消耗：43.8 MB, 在所有 Java 提交中击败了54.33%的用户
 */
class Solution {
    // 初始化最大深度和累加和
    int depth = 0;
    int sum = 0;

    public int deepestLeavesSum(TreeNode root) {
        dfs(root, 0);
        return sum;
    }

    void dfs(TreeNode root, int level) {
        if (root == null)
            return;
        // 当前访问的层数更深，则刷新depth + 重置计数器 + 计数器累加
        if (level > depth) {
            sum = 0;
            depth = level;
            sum += root.val;
        } else if (level == depth) {
            // 当前访问的层数与记录的最大深度相同，则直接计数器累加
            sum += root.val;
        }
        dfs(root.left, level + 1);
        dfs(root.right, level + 1);
    }
}

---

如果有更好的解题思路欢迎留言评论区