当前位置：首页 > news >正文

LeetCode算法题(Go语言实现)_40

news 来源：原创 2025/6/17 3:18:19

题目

给你一个二叉树的根节点 root。设根节点位于二叉树的第 1 层，而根节点的子节点位于第 2 层，依此类推。
请返回层内元素之和最大的那几层（可能只有一层）的层号，并返回其中最小的那个。

一、代码实现

import "math"

func maxLevelSum(root *TreeNode) int {
    if root == nil {
        return 0
    }
    
    queue := []*TreeNode{root}
    maxSum := math.MinInt64
    result := 0
    level := 1
    
    for len(queue) > 0 {
        size := len(queue)
        sum := 0
        for i := 0; i < size; i++ {
            node := queue[0]
            queue = queue[1:]
            sum += node.Val
            
            if node.Left != nil {
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
                queue = append(queue, node.Right)
            }
        }
        
        if sum > maxSum {
            maxSum = sum
            result = level
        }
        level++
    }
    
    return result
}

二、算法分析

1. 核心思路

层次遍历（BFS）：利用队列实现广度优先搜索，逐层计算节点值之和
动态极值追踪：实时比较并更新最大层和及其对应最小层号

2. 关键步骤

队列初始化：根节点入队
层级统计：记录当前层节点数，遍历时累加节点值
极值更新：比较当前层和与历史最大值，更新最大值及对应层号
层级递进：处理完每层后递增层号计数器

3. 复杂度

指标	值	说明
时间复杂度	O(n)	每个节点遍历一次
空间复杂度	O(n)	队列最大存储空间为最宽层节点数

三、图解示例

在这里插入图片描述

四、边界条件与扩展

1. 特殊场景验证

空树：返回0
单节点树：返回层号1
负数和层：正确识别负数层和的最大值
平局层和：返回最先出现的较小层号

2. 多语言实现

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

from collections import deque

class Solution:
    def maxLevelSum(self, root: TreeNode) -> int:
        if not root:
            return 0
        
        max_sum = float('-inf')
        result_level = 0
        level = 1
        queue = deque([root])
        
        while queue:
            level_sum = 0
            level_size = len(queue)
            
            for _ in range(level_size):
                node = queue.popleft()
                level_sum += node.val
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            
            if level_sum > max_sum:
                max_sum = level_sum
                result_level = level
            level += 1
        
        return result_level

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

class Solution {
    public int maxLevelSum(TreeNode root) {
        if (root == null) return 0;
        
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int maxSum = Integer.MIN_VALUE;
        int result = 0;
        int level = 1;
        
        while (!queue.isEmpty()) {
            int size = queue.size();
            int sum = 0;
            
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                sum += node.val;
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
            
            if (sum > maxSum) {
                maxSum = sum;
                result = level;
            }
            level++;
        }
        
        return result;
    }
}