求二叉树中层数最深的叶子节点的和

一、问题描述

Description

给定一个二叉树（按照完全二叉树规则以一维数组的形式给出，数组中如果出现0指对应位置没有节点，

比如数组[1,2,3,4,5,0,6,7,0,0,0,0,0,0,8]等价于下面的二叉树

本题要求输出所给二叉树（以数组形式）层数最深的叶子节点的和，

如上图最深层有两个叶子节点，其值分别为7和8，所以应输出 15

Input

输入为一行，形如：1 2 2 3 4 4 3

Output

输出为所给二叉树层数最深的叶子节点的和

Sample Input 1 

1 2 3

Sample Output 1

5

Sample Input 2 

1 2 3 4 5 0 6 7 0 0 0 0 0 0 8

Sample Output 2

15

二、完整代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        String[] divint = str.split(" ");
        int sum = calculateDeepestLeavesSum(divint);
        System.out.println(sum);
    }

    public static int calculateDeepestLeavesSum(String[] divint) {
        int sum = 0;
        int level = 0;
        int index = 0;
        int n = divint.length;
        int h = 0;
        int flag = 0;

        for (int i = 0; i < n; i++) {
            int j = i + 1;
            int value = Integer.parseInt(divint[i]);

            if (j == 1 || j % flag == 0) {
                flag = j;
                h++;
            }

            if (h == level) {
                sum += value;
            } else {
                level = h;
                sum = value;
            }
        }

        return sum;
    }
}

三、代码解读

当调用 calculateDeepestLeavesSum 函数时，它会计算给定输入字符串数组中最深层叶子节点的和。下面是函数内部逻辑的详细解释：

1. 函数参数：

   public static int calculateDeepestLeavesSum(String[] divint) 

   这个函数接收一个字符串数组 divint 作为输入参数，该数组包含了一组用空格分隔的整数。

2. 初始化变量：

   int sum = 0; int level = 0; int h = 0; int flag = 0;

   • sum 用于存储最深层叶子节点的和。
   • level 表示当前叶子节点的层数，初始为0。
   • h 表示当前节点的高度，初始为0。
   • flag 用于标记当前处理的是第几层的节点，初始为0。

3. 遍历输入的字符串数组 divint：

   for (int i = 0; i < divint.length; i++) 

   在这个循环中，函数会逐个处理输入的整数。

4. 处理每个数字：

   int j = i + 1; int value = Integer.parseInt(divint[i]);

   • j 表示当前处理数字的索引加1，用于判断是否是新的一层。
   • value 是当前处理的整数值。

5. 更新 flag 和 h：

   if (j == 1 || j % flag == 0) { flag = j; h++; }

   如果 j 是1（即第一个数字）或者是 flag 的倍数，说明遇到了新的一层的节点。此时，将 flag 更新为 j，并将 h 增加1。这样，flag 就成为当前处理层的标记。

6. 判断是否为同一层的节点并更新 sum：

   if (h == level) { sum += value; } else { level = h; sum = value; }

   如果当前高度 h 等于 level，表示叶子节点在同一层。在这种情况下，将当前数字的值加到 sum 上。如果 h 不等于 level，表示遇到了新的一层，此时将 level 更新为 h，并将 sum 更新为当前数字的值。

7. 循环结束后返回 sum：

   return sum;

   循环处理完所有输入的数字后，函数返回计算得到的 sum，这个值代表了最深层叶子节点的和。

总结来说，这个函数的逻辑主要是遍历输入的数字，根据数字的层级信息，将同一层级的叶子节点的值相加，最终得到最深层叶子节点的和，并将其返回。函数通过 flag 和 h 变量来判断节点的层级，通过 level 变量来记录当前处理的层级，通过 sum 变量来累加同一层级的节点的值。

接下来在输入为"1 2 3 4 5 0 6 7 0 0 0 0 0 0 8"的情况下，我将详细说明函数的执行过程：

1. 初始状态：

   • sum = 0 （用于存储最深层叶子节点的和）
   • level = 0 （用于跟踪当前层级）
   • flag = 0 （用于跟踪当前层级的第一个元素的索引）
   • h = 0 （用于跟踪当前层级的深度）

2. 第一次迭代：

   • i = 0，j = 1，value = 1
   • j == 1，所以flag = 1，h = 1，level = 1，sum = 1

3. 第二次迭代：

   • i = 1，j = 2，value = 2
   • j % flag == 0，所以flag = 2，h = 2，level != h，所以level = 2，sum = 2

4. 第三次迭代：

   • i = 2，j = 3，value = 3
   • j % flag == 0，所以flag = 3，h = 3，level != h，所以level = 3，sum = 3

5. 第四次迭代：

   • i = 3，j = 4，value = 4
   • j % flag == 0，所以flag = 4，h = 4，level != h，所以level = 4，sum = 4

6. 第五次迭代：

   • i = 4，j = 5，value = 5
   • j % flag == 0，所以flag = 5，h = 5，level != h，所以level = 5，sum = 5

7. 第六次迭代：

   • i = 5，j = 6，value = 0
   • j % flag != 0，所以sum 不变。

8. 第七次迭代：

   • i = 6，j = 7，value = 6
   • j % flag == 0，所以flag = 7，h = 6，level != h，所以level = 6，sum = 6

9. 第八次迭代：

   • i = 7，j = 8，value = 7
   • j % flag == 0，所以flag = 8，h = 7，level != h，所以level = 7，sum = 7

10. 第九次迭代：

    • i = 8，j = 9，value = 0
    • j % flag != 0，所以sum 不变。

11. 第十次迭代：

    • i = 9，j = 10，value = 0
    • j % flag != 0，所以sum 不变。

12. 第十一次迭代：

    • i = 10，j = 11，value = 0
    • j % flag != 0，所以sum 不变。

13. 第十二次迭代：

    • i = 11，j = 12，value = 0
    • j % flag != 0，所以sum 不变。

14. 第十三次迭代：

    • i = 12，j = 13，value = 0
    • j % flag != 0，所以sum 不变。

15. 第十四次迭代：

    • i = 13，j = 14，value = 0
    • j % flag != 0，所以sum 不变。

16. 第十五次迭代：

    • i = 14，j = 15，value = 8
    • j % flag == 0，所以flag = 15，h = 8，level != h，所以level = 8，sum = 8

最终，sum 的值为15。