leetcode--层数最深叶子节点的和

liulanba

于 2024-07-09 13:08:45 发布

阅读量444

点赞数 4

分类专栏： leetcode 文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/liulanba/article/details/140292815

版权

leetcode 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

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 = val
        self.left = left
        self.right = right

# BFS方法返回层数最深的叶子节点的和
def deepestLeavesSumBFS(root):
    if not root:
        return 0

    queue = deque([root])
    while queue:
        level_sum = 0
        for _ in range(len(queue)):
            node = queue.popleft()
            level_sum += node.val
            if 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   9
    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)

    result = deepestLeavesSumBFS(root)
    print("层数最深的叶子节点的和 (BFS):", result)  # 应该输出24

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

# 定义二叉树节点类
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# DFS方法返回层数最深的叶子节点的和
def deepestLeavesSumDFS(root):
    if not root:
        return 0

    max_depth = -1
    sum_at_max_depth = 0

    def dfs(node, depth):
        nonlocal max_depth, sum_at_max_depth
        if not node:
            return

        # 如果是叶子节点
        if not node.left and not node.right:
            if depth > max_depth:
                max_depth = depth
                sum_at_max_depth = node.val
            elif depth == max_depth:
                sum_at_max_depth += node.val
        else:
            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   9
    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)

    result = deepestLeavesSumDFS(root)
    print("层数最深的叶子节点的和 (DFS):", result)  # 应该输出24

go实现

广度优先搜索（BFS）

package main

import (
	"fmt"
)

// TreeNode 定义二叉树节点
type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

// deepestLeavesSumBFS 使用广度优先搜索（BFS）返回层数最深的叶子节点的和
func deepestLeavesSumBFS(root *TreeNode) int {
	if root == nil {
		return 0
	}

	queue := []*TreeNode{root}
	var levelSum int

	for len(queue) > 0 {
		levelSum = 0
		qLen := len(queue)
		for i := 0; i < qLen; i++ {
			node := queue[0]
			queue = queue[1:]
			levelSum += node.Val
			if 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   9
	root := &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 main

import (
	"fmt"
)

// TreeNode 定义二叉树节点
type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

// deepestLeavesSumDFS 使用深度优先搜索（DFS）返回层数最深的叶子节点的和
func deepestLeavesSumDFS(root *TreeNode) int {
	if root == nil {
		return 0
	}

	var maxDepth int
	var sumAtMaxDepth int

	var 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 = depth
				sumAtMaxDepth = 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   9
	root := &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? = null
    var right: TreeNode? = null
}

// BFS方法返回层数最深的叶子节点的和
fun deepestLeavesSumBFS(root: TreeNode?): Int {
    if (root == null) return 0

    var sum = 0
    val queue: Queue<TreeNode> = LinkedList()
    queue.add(root)

    // 广度优先搜索（BFS）
    while (queue.isNotEmpty()) {
        sum = 0 // 重置当前层的和
        val size = queue.size
        for (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   9
    val 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? = null
    var right: TreeNode? = null
}

// DFS方法返回层数最深的叶子节点的和
fun deepestLeavesSumDFS(root: TreeNode?): Int {
    if (root == null) return 0

    var maxDepth = -1
    var sumAtMaxDepth = 0

    fun dfs(node: TreeNode?, depth: Int) {
        if (node == null) return

        // 如果是叶子节点
        if (node.left == null && node.right == null) {
            if (depth > maxDepth) {
                maxDepth = depth
                sumAtMaxDepth = 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   9
    val 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
}