【每日一题记录】层数最深叶子节点的和

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第17天，点击查看活动详情

大家好 我是短袖撸码蒂尔尼。今天带来的是一道在LeetCode上的题目，题目难度不大。但我好久没做过这种题目了并且最近在进行代码题复习，就在此为大家分享一下解答思路。

题目阐述

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

示例

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

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

提示：

• 树中节点数目在范围 [1, 104] 之间。
• 1 <= Node.val <= 100
• 原题在这里

思路阐述

既然是二叉树的题目，那根据二叉树第一定律：

二叉树的题目都离不开递归

我的第一思路是dfs进行递归

• 建立自定义类型nodeinfo 记录当前遍历的层次level和层次最深的节点和count
• 根节点的最深层次节点和等于左子树的最深层次节点和和右子树最深层次最深节点和
• 递归方法deepsearch(TreeNode,{ level, count }: nodeinfo)：nodeinfo返回最深的层次和节点和:
  • 当节点有2个子节点的时候，进行**deepsearch(TreeNode,{ level+1, count }: nodeinfo)**判断：
    • 最深层次 比较 若相同 则返回 (level,leftcount+rightcount)
  • 当节点无子节点的时候：
    • 当节点为空的时候 返回 (level-1,count)
    • 当节点值有定义的时候 返回 {level,count:node.val}

实现代码

type nodeinfo = { level: number; count: number };
function deepestLeavesSum(root: TreeNode | null): number {
    return deepsearch(root,{level:0,count:root.val}).count
 }

function deepsearch(
    node: TreeNode | null,
    { level, count }: nodeinfo
): nodeinfo {
    if (node === null) return { level: level - 1, count };
    //还有子节点
    if (!node.left && !node.right) { return { level: level + 1, count: node.val } }
    let leftinfo = deepsearch(node.left, { level: level + 1, count: count });
    let rightinfo = deepsearch(node.right, { level: level + 1, count: count });

    return leftinfo.level == rightinfo.level ? { level: leftinfo.level, count: leftinfo.count + rightinfo.count } : (leftinfo.level > rightinfo.level ? { level: leftinfo.level, count: leftinfo.count } : {
        level: rightinfo.level, count: rightinfo.count
    })
}

A了个148ms 看来是递归的老毛病了。。。看看有没有优化的方法

其他思路

BFS的思路 就是用一个队列层序遍历去完成bfs的搜索

作者：LeetCode-Solution
var deepestLeavesSum = function(root) {
    let sum = 0;
    const queue = [];
    queue.push(root);
    while (queue.length) {
        sum = 0;
        const size = queue.length;
        for (let i = 0; i < size; i++) {
            const node = queue.shift();
            sum += node.val;
            if (node.left) {
                queue.push(node.left);
            }
            if (node.right) {
                queue.push(node.right);
            }
        }
    }
    return sum;
};

这个思路的好处就是不用算最深的深度，直接算层次和。
但是耗时好像没什么明显的变化
这可能是typescript的问题吧

我是短袖撸码蒂尔尼
一名热爱阿森纳的前端工程师
如果本文对您有帮助，可以给一个免费的赞吗？谢谢！