力扣：1302. 层数最深叶子节点的和

最新推荐文章于 2024-08-10 22:52:22 发布

what is an object

最新推荐文章于 2024-08-10 22:52:22 发布

阅读量88

点赞数

分类专栏：菜鸟刷题记录算法文章标签： leetcode 深度优先算法

本文链接：https://blog.csdn.net/newOneObject/article/details/126396309

版权

算法同时被 2 个专栏收录

278 篇文章 1 订阅

订阅专栏

菜鸟刷题记录

204 篇文章 1 订阅

订阅专栏

这篇博客介绍了如何利用深度优先搜索(DFS)和广度优先搜索(BFS)算法解决寻找二叉树最深叶子节点之和的问题。两种方法分别实现，通过遍历树的节点并维护最大深度和当前深度，最终得到最深叶子节点的和。代码示例详细展示了Java实现过程。

摘要由CSDN通过智能技术生成

只需要找出最深的节点是什么，然后累加结果就行

dfs

// 最大深度
    int depth = -1;
    // 总和
    int sum = 0;
    public int deepestLeavesSum(TreeNode root) {
        dfs(root, 0);
        return sum;
    }

    /**
     * 深度优先遍历，维护一个最大深度和对应的结果值
     * 有三种情况： 1，当前 遍历的深度大于记录的最大深度，那么更新记录的最大深度，结果重置
     *             2.当前深度等于记录的最大深度，累计结果
     *             3.当前深度小于记录的最大深度，跳过
     * @param node
     * @param level
     */
    private void dfs (TreeNode node, int level){
        if (node == null){
            return;
        }
        if (level > depth){
            sum = node.val;
            depth = level;
        } else if (level == depth){
            sum += node.val;
        }
        dfs(node.left, level + 1);
        dfs(node.right, level + 1);
    }

bfs

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int deepestLeavesSum(TreeNode root) {
        if (root == null){
            return 0;
        }

        int sum = 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            int count = 0;
            int size = queue.size();
            for (int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                count += node.val;
                if (node.left != null){
                    queue.offer(node.left);
                }
                if (node.right != null){
                    queue.offer(node.right);
                }
            }
            sum = count;
        }
        return sum;
    }
}

完整代码

package com.算法专练.力扣.层数最深叶子节点的和;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;

/**
 * @author xnl
 * @Description:
 * @date: 2022/8/17   23:00
 */
public class Solution {
    public static void main(String[] args) {
        Solution solution = new Solution();

    }

    // 最大深度
    int depth = -1;
    // 总和
    int sum = 0;
    public int deepestLeavesSum(TreeNode root) {
        dfs(root, 0);
        return sum;
    }

    /**
     * 深度优先遍历，维护一个最大深度和对应的结果值
     * 有三种情况： 1，当前 遍历的深度大于记录的最大深度，那么更新记录的最大深度，结果重置
     *             2.当前深度等于记录的最大深度，累计结果
     *             3.当前深度小于记录的最大深度，跳过
     * @param node
     * @param level
     */
    private void dfs (TreeNode node, int level){
        if (node == null){
            return;
        }
        if (level > depth){
            sum = node.val;
            depth = level;
        } else if (level == depth){
            sum += node.val;
        }
        dfs(node.left, level + 1);
        dfs(node.right, level + 1);
    }

    /**
     * bsf
     *  深度优先遍历
     * @param root
     * @return
     */
    public int bfs(TreeNode root) {
        if (root == null){
            return 0;
        }

        int sum = 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            int count = 0;
            int size = queue.size();
            for (int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                count += node.val;
                if (node.left != null){
                    queue.offer(node.left);
                }
                if (node.right != null){
                    queue.offer(node.right);
                }
            }
            sum = count;
        }
        return sum;
    }
    
}

class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode() {}
      TreeNode(int val) { this.val = val; }
      TreeNode(int val, TreeNode left, TreeNode right) {
          this.val = val;
          this.left = left;
          this.right = right;
      }
  }