Update 129.求根到叶子节点数字之和 with cpp code

Author: suukii

basic/binary-tree/15.sum-root-to-leaf-numbers.md

@@ -7,11 +7,11 @@ https://leetcode-cn.com/problems/sum-root-to-leaf-numbers
   - [方法 1：递归](#方法-1递归)
     - [思路](#思路)
     - [复杂度](#复杂度)
-    - [代码](#代码)
+    - [代码(JavaScript/Python/C++)](#代码javascriptpythonc)
   - [方法 2：BFS](#方法-2bfs)
     - [思路](#思路-1)
     - [复杂度](#复杂度-1)
-  - [代码](#代码-1)
+  - [代码(JavaScript/C++)](#代码javascriptc)
 
 ## 题目描述
 
@@ -58,11 +58,11 @@ https://leetcode-cn.com/problems/sum-root-to-leaf-numbers
 
 ### 思路
 
-lucifer 的[递归小技巧](https://github.com/leetcode-pp/91alg-1/issues/32#issuecomment-643620727)练习课堂。
+lucifer 的**递归小技巧**练习课堂。
 
 1. 定义函数功能，先不用管其具体实现。
 
-    我们需要一个函数，给定一个二叉树的根节点，返回根节点到各个叶子节点连成的数字的和。假设我们已经有这个函数 `F`，那问题就转化为 `F(root)` 了。
+    首先我们需要一个函数，给定一个二叉树的根节点，返回根节点到各个叶子节点连成的数字的和。假设我们已经有这个函数 `F`，那问题转化成 `F(root)`。
 
     唔...其实问题还要复杂一丢丢，因为我们得要遍历到叶子节点的时候才能确定连成的数字，而要知道这个数字是什么，还要知道这个叶子节点的父节点，以及它父节点的父节点，...，一直到根节点，也就是说我们需要在遍历开始的时候就用一个变量来记录走过的节点。那现在我们的问题就转化成了 `F(root, num)`。
 
@@ -83,7 +83,7 @@ lucifer 的[递归小技巧](https://github.com/leetcode-pp/91alg-1/issues/32#is
 -   时间复杂度: $O(N)$，N 为二叉树节点数。
 -   空间复杂度: $O(h)$，h 为二叉树高度。
 
-### 代码
+### 代码(JavaScript/Python/C++)
 
 JavaScript Code
 
@@ -129,19 +129,48 @@ class Solution(object):
         return self.sumNumbers(root.left, num) + self.sumNumbers(root.right, num)
 ```
 
+C++ Code
+
+```cpp
+/**
+ * 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` 中。
--   如果当前节点没有子节点了，就把它的值加到结果中。
+-   对二叉树进行层级遍历，将每一层节点的数字传给下一层，存在 `node.val` 中。
+-   如果当前节点没有子节点了，就可以把它的值加到结果中去了。
 
 ### 复杂度
 
 -   时间复杂度: $O(N)$，N 为二叉树节点数。
 -   空间复杂度: $O(q)$，q 为队列长度。最坏情况是满二叉树，此时 q 为 $2/N$，即为 $O(N)$，N 为二叉树节点数。
 
-## 代码
+## 代码(JavaScript/C++)
 
 JavaScript Code
 
@@ -184,3 +213,52 @@ var sumNumbers = function (root) {
     return sum;
 };
 ```
+
+C++ Code
+
+```cpp
+/**
+ * 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](https://github.com/suukii/91-days-algorithm)