leetcode地址：层数最深叶子节点的和
给你一棵二叉树的根节点 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, 104] 之间。
1 <= Node.val <= 100

实现思路

广度优先搜索（BFS）：

使用队列进行层次遍历，逐层扫描树。
每次进入新的一层时，重置当前层的和。
记录当前层的叶子节点和，直到遍历完整棵树。
深度优先搜索（DFS）：

使用递归方法，记录每个节点的层数。
通过递归遍历树，更新当前层数和最深层叶子节点和。
返回最深层叶子节点和。

代码详解

广度优先搜索（BFS）
使用广度优先搜索（BFS）遍历树，每次进入新的一层时，重置当前层的和，并累加当前层的叶子节点值，直到遍历完整棵树。

from collections import deque# 定义二叉树节点类
class TreeNode:def __init__(self, val=0, left=None, right=None):self.val = valself.left = leftself.right = right# BFS方法返回层数最深的叶子节点的和
def deepestLeavesSumBFS(root):if not root:return 0queue = deque([root])while queue:level_sum = 0for _ in range(len(queue)):node = queue.popleft()level_sum += node.valif node.left:queue.append(node.left)if node.right:queue.append(node.right)return level_sum# 测试示例
if __name__ == "__main__":# 创建测试二叉树#        1#       / \#      2   3#     / \   \#    4   5   6#   /       / \#  7       8   9root = TreeNode(1)root.left = TreeNode(2)root.right = TreeNode(3)root.left.left = TreeNode(4)root.left.right = TreeNode(5)root.right.right = TreeNode(6)root.left.left.left = TreeNode(7)root.right.right.left = TreeNode(8)root.right.right.right = TreeNode(9)result = deepestLeavesSumBFS(root)print("层数最深的叶子节点的和 (BFS):", result)  # 应该输出24

深度优先搜索（DFS）
使用深度优先搜索（DFS）遍历树，记录每个节点的层数。通过递归遍历树，更新当前层数和最深层叶子节点和。

# 定义二叉树节点类
class TreeNode:def __init__(self, val=0, left=None, right=None):self.val = valself.left = leftself.right = right# DFS方法返回层数最深的叶子节点的和
def deepestLeavesSumDFS(root):if not root:return 0max_depth = -1sum_at_max_depth = 0def dfs(node, depth):nonlocal max_depth, sum_at_max_depthif not node:return# 如果是叶子节点if not node.left and not node.right:if depth > max_depth:max_depth = depthsum_at_max_depth = node.valelif depth == max_depth:sum_at_max_depth += node.valelse:dfs(node.left, depth + 1)dfs(node.right, depth + 1)dfs(root, 0)return sum_at_max_depth# 测试示例
if __name__ == "__main__":# 创建测试二叉树#        1#       / \#      2   3#     / \   \#    4   5   6#   /       / \#  7       8   9root = TreeNode(1)root.left = TreeNode(2)root.right = TreeNode(3)root.left.left = TreeNode(4)root.left.right = TreeNode(5)root.right.right = TreeNode(6)root.left.left.left = TreeNode(7)root.right.right.left = TreeNode(8)root.right.right.right = TreeNode(9)result = deepestLeavesSumDFS(root)print("层数最深的叶子节点的和 (DFS):", result)  # 应该输出24

go实现

广度优先搜索（BFS）

package mainimport ("fmt"
)// TreeNode 定义二叉树节点
type TreeNode struct {Val   intLeft  *TreeNodeRight *TreeNode
}// deepestLeavesSumBFS 使用广度优先搜索（BFS）返回层数最深的叶子节点的和
func deepestLeavesSumBFS(root *TreeNode) int {if root == nil {return 0}queue := []*TreeNode{root}var levelSum intfor len(queue) > 0 {levelSum = 0qLen := len(queue)for i := 0; i < qLen; i++ {node := queue[0]queue = queue[1:]levelSum += node.Valif node.Left != nil {queue = append(queue, node.Left)}if node.Right != nil {queue = append(queue, node.Right)}}}return levelSum
}// 测试示例
func main() {// 创建测试二叉树//        1//       / \//      2   3//     / \   \//    4   5   6//   /       / \//  7       8   9root := &TreeNode{Val: 1}root.Left = &TreeNode{Val: 2}root.Right = &TreeNode{Val: 3}root.Left.Left = &TreeNode{Val: 4}root.Left.Right = &TreeNode{Val: 5}root.Right.Right = &TreeNode{Val: 6}root.Left.Left.Left = &TreeNode{Val: 7}root.Right.Right.Left = &TreeNode{Val: 8}root.Right.Right.Right = &TreeNode{Val: 9}result := deepestLeavesSumBFS(root)fmt.Printf("层数最深的叶子节点的和 (BFS): %d\n", result) // 应该输出24
}

深度优先搜索（DFS）

package mainimport ("fmt"
)// TreeNode 定义二叉树节点
type TreeNode struct {Val   intLeft  *TreeNodeRight *TreeNode
}// deepestLeavesSumDFS 使用深度优先搜索（DFS）返回层数最深的叶子节点的和
func deepestLeavesSumDFS(root *TreeNode) int {if root == nil {return 0}var maxDepth intvar sumAtMaxDepth intvar dfs func(node *TreeNode, depth int)dfs = func(node *TreeNode, depth int) {if node == nil {return}// 如果是叶子节点if node.Left == nil && node.Right == nil {if depth > maxDepth {maxDepth = depthsumAtMaxDepth = node.Val} else if depth == maxDepth {sumAtMaxDepth += node.Val}} else {dfs(node.Left, depth+1)dfs(node.Right, depth+1)}}dfs(root, 0)return sumAtMaxDepth
}// 测试示例
func main() {// 创建测试二叉树//        1//       / \//      2   3//     / \   \//    4   5   6//   /       / \//  7       8   9root := &TreeNode{Val: 1}root.Left = &TreeNode{Val: 2}root.Right = &TreeNode{Val: 3}root.Left.Left = &TreeNode{Val: 4}root.Left.Right = &TreeNode{Val: 5}root.Right.Right = &TreeNode{Val: 6}root.Left.Left.Left = &TreeNode{Val: 7}root.Right.Right.Left = &TreeNode{Val: 8}root.Right.Right.Right = &TreeNode{Val: 9}result := deepestLeavesSumDFS(root)fmt.Printf("层数最深的叶子节点的和 (DFS): %d\n", result) // 应该输出24
}

Kotlin实现

广度优先搜索（BFS）

import java.util.LinkedList
import java.util.Queue// 定义二叉树节点类
class TreeNode(var `val`: Int) {var left: TreeNode? = nullvar right: TreeNode? = null
}// BFS方法返回层数最深的叶子节点的和
fun deepestLeavesSumBFS(root: TreeNode?): Int {if (root == null) return 0var sum = 0val queue: Queue<TreeNode> = LinkedList()queue.add(root)// 广度优先搜索（BFS）while (queue.isNotEmpty()) {sum = 0 // 重置当前层的和val size = queue.sizefor (i in 0 until size) {val node = queue.poll()sum += node.`val` // 累加当前层节点的值// 将左右子节点加入队列node.left?.let { queue.add(it) }node.right?.let { queue.add(it) }}}return sum
}// 测试示例
fun main() {// 创建测试二叉树//        1//       / \//      2   3//     / \   \//    4   5   6//   /       / \//  7       8   9val root = TreeNode(1)root.left = TreeNode(2)root.right = TreeNode(3)root.left?.left = TreeNode(4)root.left?.right = TreeNode(5)root.right?.right = TreeNode(6)root.left?.left?.left = TreeNode(7)root.right?.right?.left = TreeNode(8)root.right?.right?.right = TreeNode(9)val result = deepestLeavesSumBFS(root)println("层数最深的叶子节点的和 (BFS): $result") // 应该输出24
}

深度优先搜索（DFS）

// 定义二叉树节点类
class TreeNode(var `val`: Int) {var left: TreeNode? = nullvar right: TreeNode? = null
}// DFS方法返回层数最深的叶子节点的和
fun deepestLeavesSumDFS(root: TreeNode?): Int {if (root == null) return 0var maxDepth = -1var sumAtMaxDepth = 0fun dfs(node: TreeNode?, depth: Int) {if (node == null) return// 如果是叶子节点if (node.left == null && node.right == null) {if (depth > maxDepth) {maxDepth = depthsumAtMaxDepth = node.`val`} else if (depth == maxDepth) {sumAtMaxDepth += node.`val`}} else {dfs(node.left, depth + 1)dfs(node.right, depth + 1)}}dfs(root, 0)return sumAtMaxDepth
}// 测试示例
fun main() {// 创建测试二叉树//        1//       / \//      2   3//     / \   \//    4   5   6//   /       / \//  7       8   9val root = TreeNode(1)root.left = TreeNode(2)root.right = TreeNode(3)root.left?.left = TreeNode(4)root.left?.right = TreeNode(5)root.right?.right = TreeNode(6)root.left?.left?.left = TreeNode(7)root.right?.right?.left = TreeNode(8)root.right?.right?.right = TreeNode(9)val result = deepestLeavesSumDFS(root)println("层数最深的叶子节点的和 (DFS): $result") // 应该输出24
}