问题描述:
Given a binary tree containing digits from 0-9
only, each root-to-leaf path could represent a number.
An example is the root-to-leaf path 1->2->3
which represents the number 123
.
Find the total sum of all root-to-leaf numbers.
Note: A leaf is a node with no children.
Example:
Input: [1,2,3] 1 / \ 2 3 Output: 25 Explanation: The root-to-leaf path1->2
represents the number12
. The root-to-leaf path1->3
represents the number13
. Therefore, sum = 12 + 13 =25
.
Example 2:
Input: [4,9,0,5,1] 4 / \ 9 0 / \ 5 1 Output: 1026 Explanation: The root-to-leaf path4->9->5
represents the number 495. The root-to-leaf path4->9->1
represents the number 491. The root-to-leaf path4->0
represents the number 40. Therefore, sum = 495 + 491 + 40 =1026
.
源码:
递归做法,思路很简单,效率自然不高,时间61%,空间42%。
/**
* 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 result = 0;
void help(TreeNode* root, int tmp){
if(!root->left && !root->right){
tmp = tmp*10 + root->val;
result += tmp;
return;
}
if(root->left) help(root->left, tmp*10 + root->val);
if(root->right) help(root->right, tmp*10 + root->val);
}
int sumNumbers(TreeNode* root) {
if(!root) return result;
help(root, 0);
return result;
}
};
非递归的方法,首先看看我用一个队列,模拟递归过程,因为递归中只有两个参数,所以一个Make_pair完全可以模拟,如果参数多的话,可以用多个队列,不过那样太臃肿了。看看效果吧,时间还是61%,空间92%。
/**
* 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 result = 0;
int sumNumbers(TreeNode* root) {
int result = 0, tmp = 0;
if(!root) return result;
queue<pair<TreeNode*, int>> st;
st.push(make_pair(root, 0));
while(!st.empty()){
auto node = st.front();
st.pop();
if(!node.first->left && !node.first->right){
node.second = node.first->val + node.second*10;
result += node.second;
continue;
}
if(node.first->left){
st.push(make_pair(node.first->left, node.first->val + node.second*10));
}
if(node.first->right){
st.push(make_pair(node.first->right, node.first->val + node.second*10));
}
}
return result;
}
};
中文leetcode上的方法C++ 非递归后序遍历,有点后序遍历的感觉,时间61%,空间73%。
class Solution {
public:
int sumNumbers(TreeNode* root) {
if(!root) return {};
int res = 0;
TreeNode* prev = root;
vector<TreeNode*> tree_st;
tree_st.push_back(root);
while(!tree_st.empty()){
auto cur = tree_st.back();
if(cur->left && cur->left!= prev && cur->right!=prev){
tree_st.push_back(cur->left);
}else if(cur->right && cur->right!=prev){
tree_st.push_back(cur->right);
}else{
//到了叶节点,正序遍历栈
if(!cur->left && !cur->right){
int cur_int = 0;
for_each(tree_st.cbegin(),tree_st.cend(),
[&cur_int](auto& ptr){cur_int = cur_int*10; cur_int+=ptr->val;});
//cout<<cur_int<<endl;
res += cur_int;
}
tree_st.pop_back();
prev = cur;
}
}
return res;
}
};