Path Sum I
Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.
For example:Given the below binary tree and
sum = 22
,
5 / \ 4 8 / / \ 11 13 4 / \ \ 7 2 1
return true, as there exist a root-to-leaf path 5->4->11->2
which sum is 22.
直接递归。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool hasPathSum(TreeNode* root, int sum)
{
if (!root)
return 0;
else if (!root->left && !root->right)
{
if (root->val == sum) return 1;
else return 0;
}
else
return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
}
};
Path Sum II
Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.
For example:Given the below binary tree and
sum = 22
,
5 / \ 4 8 / / \ 11 13 4 / \ / \ 7 2 5 1
return
[ [5,4,11,2], [5,8,4,5] ]
也是直接递归
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
void helper(TreeNode* p, int sum, vector<vector<int>> & result, vector<int> m1)
{
if (!p)
return;
m1.push_back(p->val);
if (!p->left && !p->right && p->val == sum)
result.push_back(m1);
helper(p->left, sum - p->val, result, m1);
helper(p->right, sum - p->val, result, m1);
}
vector<vector<int>> pathSum(TreeNode* root, int sum)
{
vector<vector<int>> result;
vector<int> m1;
helper(root, sum, result, m1);
return result;
}
};
Path Sum III
You are given a binary tree in which each node contains an integer value.
Find the number of paths that sum to a given value.
The path does not need to start or end at the root or a leaf, but it must go downwards (traveling only from parent nodes to child nodes).
The tree has no more than 1,000 nodes and the values are in the range -1,000,000 to 1,000,000.
Example:
root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8 10 / \ 5 -3 / \ \ 3 2 11 / \ \ 3 -2 1 Return 3. The paths that sum to 8 are: 1. 5 -> 3 2. 5 -> 2 -> 1 3. -3 -> 11
直接用一个queue来记录沿路的路径,每一个点都可以作为开始。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int pathSum(TreeNode* root, int target)
{
if (!root) return 0;
ret = 0;
queue<int> mp;
helper(mp, root, target);
return ret;
}
void helper(queue<int> que, TreeNode* root, int target)
{
int size = que.size();
for (int i = 0; i < size; i++)
{
int key = que.front() + root->val;
if (key == target)
ret ++;
que.pop();
que.push(key);
}
if (root->val == target) ret++;
que.push(root->val);
if (root->left) helper(que, root->left, target);
if (root->right) helper(que, root->right, target);
return;
}
private:
int ret;
};