Leetcode.1302. 层数最深叶子节点的和：从根到叶的最长路径的权重和

前端

2023-11-28 22:47:05

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

给定一棵二叉树，你需要求出二叉树中层数最深的叶子节点的和。

深度优先遍历

深度优先遍历（DFS）是一种遍历二叉树的经典算法。它通过递归或栈来实现。DFS的基本思想是，从根节点开始，依次访问每个子节点，直到达到叶子节点。然后，从叶子节点返回，访问其父节点的下一个子节点。如此循环，直到所有节点都已访问过。

广度优先遍历

广度优先遍历（BFS）是另一种遍历二叉树的经典算法。它通过队列来实现。BFS的基本思想是，从根节点开始，依次访问每一层的所有节点，直到最后一层。然后，从最后一层返回，访问下一层的第一个节点，以此类推，直到所有节点都已访问过。

Python代码实现

深度优先遍历解法

def deepest_leaves_sum(root):
    """
    :type root: TreeNode
    :rtype: int
    """
    # 如果二叉树为空，直接返回0
    if not root:
        return 0

    # 定义一个变量sum，用来存储层数最深的叶子节点的和
    sum = 0

    # 定义一个变量max_depth，用来存储二叉树的最大深度
    max_depth = 0

    # 定义一个函数dfs，用来进行深度优先遍历
    def dfs(root, depth):
        # 更新最大深度
        max_depth = max(max_depth, depth)

        # 如果当前节点是叶子节点，并且当前深度等于最大深度，则将当前节点的值加到sum中
        if not root.left and not root.right and depth == max_depth:
            sum += root.val

        # 如果当前节点不是叶子节点，则继续遍历其左子树和右子树
        if root.left:
            dfs(root.left, depth+1)
        if root.right:
            dfs(root.right, depth+1)

    # 调用dfs函数，从根节点开始进行深度优先遍历
    dfs(root, 1)

    # 返回层数最深的叶子节点的和
    return sum

广度优先遍历解法

def deepest_leaves_sum(root):
    """
    :type root: TreeNode
    :rtype: int
    """
    # 如果二叉树为空，直接返回0
    if not root:
        return 0

    # 定义一个队列queue，用来存储每一层的节点
    queue = [root]

    # 定义一个变量sum，用来存储层数最深的叶子节点的和
    sum = 0

    # 定义一个变量max_depth，用来存储二叉树的最大深度
    max_depth = 0

    # 循环遍历每一层
    while queue:
        # 更新最大深度
        max_depth += 1

        # 获取当前层的节点数量
        size = len(queue)

        # 将当前层的节点从队列中取出
        for _ in range(size):
            # 获取当前节点
            node = queue.pop(0)

            # 如果当前节点是叶子节点，并且当前深度等于最大深度，则将当前节点的值加到sum中
            if not node.left and not node.right and max_depth == max_depth:
                sum += node.val

            # 如果当前节点不是叶子节点，则将当前节点的左子树和右子树的节点加入到队列中
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

    # 返回层数最深的叶子节点的和
    return sum