Skip to content

Latest commit

 

History

History
264 lines (212 loc) · 7.35 KB

15.sum-root-to-leaf-numbers.md

File metadata and controls

264 lines (212 loc) · 7.35 KB
Raw

129.求根到叶子节点数字之和

https://leetcode-cn.com/problems/sum-root-to-leaf-numbers

题目描述

给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。

例如，从根到叶子节点路径 1->2->3 代表数字 123。

计算从根到叶子节点生成的所有数字之和。

说明: 叶子节点是指没有子节点的节点。

示例 1:

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

输入: [4,9,0,5,1]
    4
   / \
  9   0
 / \
5   1
输出: 1026
解释:
从根到叶子节点路径 4->9->5 代表数字 495.
从根到叶子节点路径 4->9->1 代表数字 491.
从根到叶子节点路径 4->0 代表数字 40.
因此，数字总和 = 495 + 491 + 40 = 1026.
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sum-root-to-leaf-numbers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法 1：递归

思路

lucifer 的递归小技巧练习课堂。

  1. 定义函数功能，先不用管其具体实现。

    首先我们需要一个函数，给定一个二叉树的根节点，返回根节点到各个叶子节点连成的数字的和。假设我们已经有这个函数 F，那问题转化成 F(root)。

    唔...其实问题还要复杂一丢丢，因为我们得要遍历到叶子节点的时候才能确定连成的数字，而要知道这个数字是什么，还要知道这个叶子节点的父节点，以及它父节点的父节点，...，一直到根节点，也就是说我们需要在遍历开始的时候就用一个变量来记录走过的节点。那现在我们的问题就转化成了 F(root, num)。

  2. 确定大问题和小问题的关系。

    首先，遍历到当前节点的时候，我们还有一点额外的工作要做，就是把当前节点的值记录到 num 中，这一步可以通过数学计算 num * 10 + root.val 来完成，或者你用字符串来拼接也行。

    再来看看 F(root, num) 和 F(root.left, num) 以及 F(root.right, num) 的关系，它们的关系就很单纯啦。

    F(root, num) = F(root.left, num) + F(root.right, num)

  3. 补充递归终止条件

    显然，当遍历到叶子节点的时候我们就可以停止了，然后把遍历中生成的数字 num 返回。另外一种情况是遍历的节点不存在，那就直接返回 0 即可。

复杂度

  • 时间复杂度: $O(N)$，N 为二叉树节点数。
  • 空间复杂度: $O(h)$，h 为二叉树高度。

代码(JavaScript/Python/C++)

JavaScript Code

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var sumNumbers = function (root, num = 0) {
    if (!root) return 0;
    num = num * 10 + root.val;
    if (!root.left && !root.right) return num;
    return sumNumbers(root.left, num) + sumNumbers(root.right, num);
};

Python Code

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def sumNumbers(self, root, num=0):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root: return 0
        num = num * 10 + root.val
        if not root.left and not root.right: return num
        return self.sumNumbers(root.left, num) + self.sumNumbers(root.right, num)

C++ Code

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int sumNumbers(TreeNode* root) {
        return sumNumbers(root, 0);
    }
    int sumNumbers(TreeNode* root, int num) {
        if (root == nullptr) return 0;
        num = num * 10 + root->val;
        if (root->left == nullptr && root->right == nullptr) return num;
        return sumNumbers(root->left, num) + sumNumbers(root->right, num);
    }

};

方法 2：BFS

思路

  • 对二叉树进行层级遍历，将每一层节点的数字传给下一层，存在 node.val 中。
  • 如果当前节点没有子节点了，就可以把它的值加到结果中去了。

复杂度

  • 时间复杂度: $O(N)$，N 为二叉树节点数。
  • 空间复杂度: $O(q)$，q 为队列长度。最坏情况是满二叉树，此时 q 为 $2/N$，即为 $O(N)$，N 为二叉树节点数。

代码(JavaScript/C++)

JavaScript Code

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var sumNumbers = function (root) {
    if (!root) return 0;

    const queue = [root];
    let sum = 0;
    while (queue.length) {
        let len = queue.length;

        while (len-- > 0) {
            const node = queue.shift();

            if (node.left) {
                node.left.val += node.val * 10;
                queue.push(node.left);
            }

            if (node.right) {
                node.right.val += node.val * 10;
                queue.push(node.right);
            }

            if (!node.left && !node.right) sum += node.val;
        }
    }
    return sum;
};

C++ Code

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int sumNumbers(TreeNode* root) {
        if (!root) return 0;

        int total = 0;
        queue<TreeNode*> level;
        level.push(root);

        while (!level.empty()) {
            int size = level.size();
            while (size--) {
                TreeNode* node = level.front();
                level.pop();

                if (node->left) {
                    node->left->val += node->val * 10;
                    level.push(node->left);
                }
                if (node->right) {
                    node->right->val += node->val * 10;
                    level.push(node->right);
                }
                if (!node->left && !node->right) {
                    total += node->val;
                }
            }
        }
        return total;
    }
};

更多题解可以访问：https://github.com/suukii/91-days-algorithm