力扣：1161. 最大层内元素和

最新推荐文章于 2025-12-05 19:39:52 发布

原创最新推荐文章于 2025-12-05 19:39:52 发布 · 85 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #深度优先

算法同时被 2 个专栏收录

278 篇文章

订阅专栏

菜鸟刷题记录

204 篇文章

订阅专栏

该博客介绍了一种使用广度优先搜索（BFS）和深度优先搜索（DFS）在Java中找到二叉树最大层和的方法。通过创建`Solution`类并定义相关方法，博主展示了如何遍历树的层次，计算每层节点值的总和，并找出最大值所在的层数。



import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

/**
 * @author xnl
 * @Description:
 * @date: 2022/7/31   21:09
 */
public class Solution {
    public static void main(String[] args) {
        Solution solution = new Solution();
        TreeNode treeNode = new TreeNode(1, new TreeNode(7, new TreeNode(7), new TreeNode(-8)), new TreeNode(0));
        System.out.println(solution.maxLevelSum(treeNode));
    }


    /**
     * 广度优先算法
     * @param root
     * @return
     */
    public int maxLevelSum(TreeNode root) {
        if (root == null){
            return 0;
        }
        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        int ans = root.val;
        int level = 0;
        int maxLevel = 1;
        while (!queue.isEmpty()){
            level++;
            int size = queue.size();
            // 临时最大值
            int temp = 0;
            for (int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                temp += node.val;
                if (node.left != null){
                    queue.offer(node.left);
                }
                if (node.right != null){
                    queue.offer(node.right);
                }
            }
            if (ans < temp){
                maxLevel = level;
                ans = temp;
            }
        }
        return maxLevel;
    }

    List<Integer> sum = new ArrayList<>();
    public int maxLevelSum2(TreeNode root) {
        dfs(root, 0);
        int ans = 0;
        for (int i = 0; i < sum.size(); i++){
            if (sum.get(i) > sum.get(ans)){
                ans = i;
            }
        }
        return ans + 1;
    }

    /**
     * 深度优先算法
     */
    private void dfs(TreeNode root, int level){
        if (level == sum.size()){
            sum.add(root.val);
        } else {
            sum.set(level, sum.get(level) + root.val);
        }
        if (root.left != null){
            dfs(root.left, level + 1);
        }
        if (root.right != null){
            dfs(root.right, level + 1);
        }
    }
}

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;
      }
  }