[路飞]_Leetcode.1302.层数最深叶子节点的和

「这是我参与2022首次更文挑战的第1天，活动详情查看：2022首次更文挑战」

题目：层数最深叶子节点的和

给你一棵二叉树的根节点 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

解析

1. 需要遍历到最后一层 然后把最后一层的值相加
2. 深度优先 或 广度优先

代码

深度优先

• 首先： 求和， 我们需要一个和的变量r
• 要记录一个节点深度是否是最后一层，所以需要的一个maxDepth 最大深度的变量0
• 因为是深度优先，我们每次向下遍历的时候，当深度大于我们的我们当前遍历情况的最大深度的时候，说明有下一层，需要把maxDepth的值更新，同时我们的和r 要重置为当前节点的值，当单前节深度等于当前最大深度的时候，代表当前节点位于当前的最大深度， 我们的和r 需要加上 当前节点的值
• 因为开始遍历的时候，根节点深度为1，因此传入当前节点的深度应该是1
• 综上： 我们可以选用递归，传入当前节点和当前节点的深度

function deepestLeavesSum(root) {
    // 定义结果和
    let r = 0
    // 定义确定的最大深度
    let maxDepth = 0
    function dfs(node, depth) {
        // 节点空的时候直接返回
        if (node === null) return
        
        if (maxDepth < depth) {
            // 出现更深一层的时候
            // 更新maxDepth
            maxDepth = depth
            // 重置 r 的 值
            r = node.val
        } else if (maxDepth === depth) {
            // 当当前节点的深度和最大深度在同一层的时候
            // 结果 相加
            r += node.val
        }
        // 当 maxDepth > depth 的时候，只要继续遍历就行
        
        // 递归左右节点
        dfs(node.left, depth + 1)
        dfs(node.right, depth + 1)
    }
    
    // 根节点和深度传入
    dfs(root, 1)
    
    return r
}
复制代码

广度优先

• 利用层序遍历到最后一个层节点把和相加
• 我的步骤是： 层序遍历然后把最后一层节点存起来，然后reduce求和

// 先定义 层序遍历 找出 最深一层的节点数组
function findMaxDepNodes(root) {
    if (root === null) return []
    const stack = [root]
    const maxDepNodes = []
    while(stack.length) {
        // 存储下一层节点
        const temp = []
        for (let i = 0; i < stack.length; i++) {
            const node = stack[i]
            
            if (node.left) temp.push(node.left)
            if (node.right) temp.push(node.right)
        }
        
        // 如果下一层没有节点， 则是最后一层
        if (temp.length === 0) {
            maxDepNodes = stack
        }
        
        stack = temp
    }
    
    return maxDepthNodes
}

function deepestLeavesSum(root) {
    const rnodes = findMaxDepNodes(root)
    return rnodes.reduce((a, b) => a + b.val, 0)
}
复制代码

总结

• 这是一道深度优先 广度优先 极好的练手
• 简单题我又来了重拳出击了