LeetCode.M1302.层数最深叶子节点的和

LeetCode.M1302

题目：

题目大意：

如图所示。

数据范围：

如图所示

---

一 、解法一 ：

思路：

由于知识的匮乏，先求出数的最大深度，然后再获得深度等于最大深度的节点之和。

代码：

//结构定义
class TreeNode{
    TreeNode left, right;
    int val;

    public TreeNode() {
    }

    public TreeNode(int val) {
        this.val = val;
    }

    public TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}
class Solution {
    //求数的最大深度
    public int getTreeMaxDeepth(TreeNode root){
        if (root == null)
            return 0;
        return Math.max(getTreeMaxDeepth(root.left), getTreeMaxDeepth(root.right)) + 1;
    }
    
    //获得深度等于最大深度的节点之和
    public int getTreeMaxDeepthSum(TreeNode root, int deep, int maxdeepth){
        if (deep > maxdeepth || root == null)
            return 0;
        if (deep == maxdeepth)
            return root.val + getTreeMaxDeepthSum(root.left, deep + 1, maxdeepth) + getTreeMaxDeepthSum(root.right, deep + 1, maxdeepth);
        else
            return getTreeMaxDeepthSum(root.left, deep + 1, maxdeepth) + getTreeMaxDeepthSum(root.right, deep + 1, maxdeepth);
    }

    public int deepestLeavesSum(TreeNode root) {
        int maxdeepth = getTreeMaxDeepth(root);
//        System.out.println(maxdeepth);
        int res = getTreeMaxDeepthSum(root, 1, maxdeepth);
        return res;
    }
}

public class Main {
    public static void main(String[] args) {
        Solution solution = new Solution();
        TreeNode treeNode1 = new TreeNode(1);
        TreeNode treeNode2 = new TreeNode(2);
        TreeNode treeNode3 = new TreeNode(3);
        treeNode1.left = treeNode2;
        treeNode1.right = treeNode3;
        TreeNode treeNode4 = new TreeNode(4);
        TreeNode treeNode5 = new TreeNode(5);
        treeNode2.left = treeNode4;
        treeNode2.right = treeNode5;
        TreeNode treeNode6 = new TreeNode(6);
        treeNode3.right = treeNode6;
        TreeNode treeNode7 = new TreeNode(7);
        treeNode4.left = treeNode7;
        TreeNode treeNode8 = new TreeNode(8);
        treeNode6.right = treeNode8;
        System.out.println(solution.deepestLeavesSum(treeNode1));
    }
}

时空复杂度分析等：

• 时间复杂度 : O(n)
• 空间复杂度 : O(n)

---

二 、解法二 ：

思路：

采用dfs，维护“最大深度”maxdeep，和处于“最大深度”的节点的和sum。

• 如果当前深度deep大于“最大深度”maxdeep，则将“最大深度”maxdeep更改为当前深度deep，相应的sum的值更改为当前节点的值（因为重新找到了一个“最大深度”maxdeep，所以sum要清零，再重新加上当前节点的值）。
• 如果当前深度deep等于“最大深度”maxdeep，则将当前节点的值val累加到sum中即可。

代码：

class Solution{
    int sum = 0;
    int maxdeep = 0;
    public void dfs(TreeNode root, int deep){
        if (root == null)
            return;
        if (deep > maxdeep){
            maxdeep = deep;
            sum = root.val;
        }else if (deep == maxdeep){
            sum += root.val;
        }
        dfs(root.left, deep + 1);
        dfs(root.right, deep + 1);
    }
    public int deepestLeavesSum(TreeNode root){
        dfs(root, 1);
        return sum;
    }
}

时空复杂度分析等：

• 时间复杂度 : O(n)
• 空间复杂度 : O(n)

三、解法三 ：

思路：

采用bfs，层序遍历树，计算每一层的节点值的和sum，那么到了最后一层遍历时，则为计算的就是最深层的节点的和。

注意：使用size来记录本层节点的数量（当前queue中节点的数量），边遍历本层的节点（size个）边将下一层的子节点加入队列中，当遍历完size个本层节点时，queue中则保存的下一层的所有节点。这样就可以获得最后一层节点值的和。

代码：

class Solution{
    public int deepestLeavesSum(TreeNode root){
        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        int sum = 0;
        while (!queue.isEmpty()){
            sum = 0;
            int size = queue.size();
            for (int i = 0; i < size; i ++ ){
                TreeNode node = queue.poll();
                sum += node.val;
                if (node.left != null)
                    queue.add(node.left);
                if (node.right != null)
                    queue.add(node.right);
            }
        }

        return sum;
    }
}

时空复杂度分析等：

• 时间复杂度 : O(n)
• 空间复杂度 : O(n)

---

题目链接：

1302. 层数最深叶子节点的和 - 力扣（LeetCode）