求根节点到叶节点数字之和

一、需求

• 给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字；
• 计算从根节点到叶节点生成的 所有数字之和 ；

      

输入：root = [1,2,3]
输出：25
解释：
从根到叶子节点路径 1->2 代表数字 12
从根到叶子节点路径 1->3 代表数字 13
因此，数字总和 = 12 + 13 = 25

提示：

• 树中节点的数目在范围 [1, 1000] 内
• 0 <= Node.val <= 9
• 树的深度不超过 10

二、递归法

2.1  思路分析

1. 用一个集合将二叉树的所有路径存储起来，然后将所有的路径转成整数并相加；
2. 这种解法效率低，不推荐；

2.2  代码实现 

class Solution {
    List<String> res = new ArrayList<>();
    String path = "";
    public int sumNumbers(TreeNode root) {
        int sum = 0;
        allPaths(root);
        for(String s : res) {
            sum += Integer.parseInt(s);
        }
        return sum;
    }
    //该方法将二叉树中从根节点到叶子节点的路径存储到list集合中
    private void allPaths(TreeNode root) {
        if(root == null) {
            return;
        }
        path += root.val;
        if(root.left == null && root.right == null) {
            //若直接填入path，后边path改变了，添加的这个也会跟着改变
            res.add(new String(path));
        }
        allPaths(root.left);
        allPaths(root.right);
        path = path.substring(0, path.length() - 1);
    }
}

2.3  复杂度分析

• 时间复杂度为O(N)，其中N为二叉树的节点个数，allPath添加路径需要遍历所有的二叉树节点；
• 空间复杂度为O(N)，字符串存储路径消耗O(N)的额外空间，list集合也消耗路径数的额外空间；

三、DFS

3.1  思路分析

1. 上一个方法递归方法的作用是将二叉树的所有路径存储到集合中，在这里换一种递归方法的定义，即求树的路径总和；
2. 这样二叉树的路径总和 = 当前节点的值 + 当前节点左子树的路径和 + 当前节点右子树的路径和；
3. 如何求这个值？每个节点对应的不完整路径值=其父节点*10 + 当前节点值，当节点为叶子节点时，此时对应着完整的路径值，因此将所有的叶子节点对应的完整路径值加起来即可；

3.2  代码实现

class Solution {
    public int sumNumbers(TreeNode root) {
        return dfs(root, 0);
    }
    private int dfs(TreeNode root, int preSum) {
        if(root == null) {
            return 0;
        }
        int sum = preSum * 10 + root.val;
        if(root.left == null && root.right == null) {
            return sum;
        } else {
            return dfs(root.left, sum) + dfs(root.right, sum);
        }
    }
}

3.3  复杂度分析

• 时间复杂度为O(N)，其中N为二叉树的节点个数，求路径和需要遍历所有的节点；
• 空间复杂度为O(N)，最坏情况下，二叉树退化为链表，递归的深度达到N；

四、BFS

4.1  思路分析

1. 我们维护两个队列，一个队列用来存储当前节点，一个队列存储当前节点对应的值；
2. 如果当前节点是叶子节点，则将该节点对应的数字加到数字之和；
3. 如果当前节点不是叶子节点，则获得当前节点的非空子节点，并根据当前节点对应的数字和子节点的值计算子节点对应的数字，然后将子节点和子节点对应的数字分别加入两个队列；
4. 搜索结束后，即可得到所有叶子节点对应的数字之和；

4.2  代码实现

class Solution {
    public int sumNumbers(TreeNode root) {
        if(root == null) {
            return 0;
        }
        int sum = 0;
        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<Integer> queue2 = new LinkedList<>();
        queue1.offer(root);
        queue2.offer(root.val);
        //直到所有节点对应的数字加完为止
        while(queue1.size() != 0) {
            TreeNode node = queue1.poll();
            //你为什么要取出它？为什么命名为sum?若当前是最后一个叶子节点的话，就要返回这个值了
            int num = queue2.poll();
            if(node.left == null && node.right == null) {
                sum += num;
            } else {
                if(node.left != null) {
                    queue1.offer(node.left);
                    queue2.offer(num * 10 + node.left.val);
                }
                if(node.right != null) {
                    queue1.offer(node.right);
                    queue2.offer(num * 10 + node.right.val);
                }
            }
        }
        return sum;
    }
}

4.3  复杂度分析

• 时间复杂度为O(N)，其中N为二叉树的节点个数；
• 空间复杂度为O(N)，每个队列最多存储N个节点；

五、学习地址

作者：LeetCode-Solution

链接：https://leetcode-cn.com/problems/sum-root-to-leaf-numbers/solution/qiu-gen-dao-xie-zi-jie-dian-shu-zi-zhi-he-by-leetc/