华为OD机试真题——传递悄悄话（二叉树最长路径问题）（2025A卷：200分）Java/python/JavaScript/C/C++/GO最佳实现

2025 A卷 200分 题型

本专栏内全部题目均提供Java、python、JavaScript、C、C++、GO六种语言的最佳实现方式；

并且每种语言均涵盖详细的问题分析、解题思路、代码实现、代码详解、3个测试用例以及综合分析；

本文收录于专栏：《2025华为OD真题目录+全流程解析+备考攻略+经验分享》

华为OD机试真题《传递悄悄话（二叉树最长路径问题）》：

---

文章快捷目录

题目描述及说明

Java

python

JavaScript

C++

C

GO

更多内容

---

题目名称：传递悄悄话（二叉树最长路径问题）

---

1. 知识点：二叉树、DFS/BFS、路径和计算
2. 时间限制：1秒
3. 空间限制：256MB
4. 限定语言：不限

---

题目描述

给定一个二叉树，每个节点上站一个人，节点数字表示父节点到该节点传递悄悄话需要的时间。初始时，根节点的人有一个悄悄话要传递给其他人。计算所有节点都接收到悄悄话的最长时间（即从根节点到最远叶子节点的路径时间和）。

输入描述
一行整数序列，表示二叉树的层序遍历结果，-1表示空节点。例如：
0 9 20 -1 -1 15 7 -1 -1 -1 -1 3 2

输出描述
一个整数，表示所有节点接收悄悄话的最长时间。例如输入上述序列，输出38（路径0→20→7→3→2的时间总和）。

示例说明

• 输入0 -1 10 -1 -1，输出10（路径0→10）。
• 输入0 3 4 -1 -1 -1 -1，输出4（路径0→4）。

---

Java

问题分析

题目要求计算二叉树中从根到最远叶子节点的路径时间和。每个节点的值表示父节点到该节点的传递时间，要求找到所有节点接收悄悄话的最长时间。

解题思路

1. 构建二叉树：根据输入的层序遍历数组构建二叉树结构，其中 -1 表示空节点。
2. 深度优先搜索 (DFS)：遍历所有从根到叶子的路径，计算路径时间和的最大值。路径和为路径上所有节点值的总和（包括根节点）。

代码实现

import java.util.*;

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

public class Main {
   
    public static void main(String[] args) {
   
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        Integer[] nums = parseInput(line);
        TreeNode root = buildTree(nums);
        int max = dfs(root, 0); // 计算路径和（包含根节点）
        System.out.println(max);
    }

    // 将输入字符串解析为 Integer 数组（处理 -1）
    private static Integer[] parseInput(String line) {
   
        String[] parts = line.split(" ");
        Integer[] nums = new Integer[parts.length];
        for (int i = 0; i < parts.length; i++) {
   
            if (parts[i].equals("-1")) {
   
                nums[i] = null;
            } else {
   
                nums[i] = Integer.parseInt(parts[i]);
            }
        }
        return nums;
    }

    // 构建层序二叉树
    private static TreeNode buildTree(Integer[] nums) {
   
        if (nums == null || nums.length == 0 || nums[0] == null) return null;
        TreeNode root = new TreeNode(nums[0]);
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int i = 1;
        while (!queue.isEmpty() && i < nums.length) {
   
            TreeNode node = queue.poll();
            // 处理左子节点
            if (i < nums.length && nums[i] != null) {
   
                node.left = new TreeNode(nums[i]);
                queue.add(node.left);
            }
            i++;
            // 处理右子节点
            if (i < nums.length && nums[i] != null) {
   
                node.right = new TreeNode(nums[i]);
                queue.add(node.right);
            }
            i++;
        }
        return root;
    }

    // DFS 计算从根到叶子的最大路径和
    private static int dfs(TreeNode node, int currentSum) {
   
        if (node == null) return currentSum; // 空节点返回当前和
        currentSum += node.val; // 累加当前节点值
        if (node.left == null && node.right == null) {
   
            return currentSum; // 叶子节点返回总和
        }
        int leftSum = dfs(node.left, currentSum);
        int rightSum = dfs(node.right, currentSum);
        return Math.max(leftSum, rightSum);
    }
}

代码解析

1. 输入处理：
   • parseInput 将输入字符串转换为 Integer 数组，-1 转为 null。
2. 构建二叉树：
   • 使用队列按层序处理每个节点的左右子节点，null 表示空节点。
3. DFS 计算路径和：
   • 递归遍历所有路径，累加节点值，叶子节点返回路径和，非叶子节点返回左右子树的最大路径和。

示例测试

1. 示例输入：

   0 9 20 -1 -1 15 7 -1 -1 -1 -1 3 2
   

   输出：40
   解释：路径 0 → 20 → 15 → 3 → 2 的和为 0 + 20 + 15 + 3 + 2 = 40。

2. 测试用例1：
   输入：

   0 -1 10 -1 -1
   

   输出：10
   解释：路径 0 → 10 的和为 0 + 10 = 10。

3. 测试用例2：
   输入：

   0 3 4 -1 -1 -1 -1
   

   输出：4
   解释：路径 0 → 4 的和为 0 + 4 = 4。

综合分析

1. 时间复杂度：O(n)
   • 构建二叉树和 DFS 遍历各需一次线性遍历。
2. 空间复杂度：O(n)
   • 存储二叉树和递归栈空间。
3. 正确性保证：
   • DFS 确保遍历所有路径，取最大值逻辑正确。
4. 适用性：
   • 适用于题目约束（n ≤ 20000，节点值 ≤ 10000），能处理大规模输入。

---

python

问题分析

题目要求计算从二叉树根节点到最远叶子节点的路径时间和的最大值。每个节点的值表示父节点到该节点的传递时间。例如，路径根节点→A→B的时间总和为父节点到A的时间加上A到B的时间。

解题思路

1. 构建二叉树：根据输入的层序遍历数组构建二叉树，其中 -1 表示空节点。
2. 深度优先搜索 (DFS)：递归计算所有从根到叶子的路径时间和，取最大值。路径和为路径节点的值之和。

---

代码实现

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

def build_tree(level_order):
    """
    根据层序遍历数组构建二叉树
    :param level_order: 层序数组，-1转换为None
    :return: 根节点
    """
    if not level_order or level_order[0] is None:
        return None
    root