leetcode 113. Path Sum II DFS深度优先遍历

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]

]

这道题就是一个普通的DFS深度优先遍历，不过这里要求到叶子节点，所以这个和二叉树的遍历稍有不同，直接上代码吧！

建议和leetcode 437. Path Sum III 深度优先遍历DFS 和 leetcode 112. Path Sum DFS深度优先遍历 一起学习

代码如下：

import java.util.ArrayList;
import java.util.List;

/*class TreeNode
{
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}*/

public class Solution
{
List<List<Integer>> res=new ArrayList<>();
public List<List<Integer>> pathSum(TreeNode root, int sum)
{
if(root==null)
return res;
List<Integer> one=new ArrayList<>();
byRecursion(root,one,sum,0);
return res;
}

public void byRecursion(TreeNode root,List<Integer> one,int target,int sum)
{
if(root==null)
return;
else
{
//左右的子节点都为null的时候，就表明走到了叶节点了
if(root.left==null && root.right==null)
{
one.add(root.val);
if(sum+root.val==target)
{
List<Integer> t=new ArrayList<>(one);
res.add(t);
}
one.remove(one.size()-1);
return;
}
//左子树遍历
if(root.left!=null)
{
one.add(root.val);
byRecursion(root.left,one,target,sum+root.val);
one.remove(one.size()-1);
}
//右子树遍历
if(root.right!=null)
{
one.add(root.val);
byRecursion(root.right,one,target,sum+root.val);
one.remove(one.size()-1);
}
}
}
}

下面是C++的做法，就是一个DFS深度优先遍历的做法

代码如下：

#include <iostream>
#include <vector>

using namespace std;

/*
struct TreeNode
{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
*/

class Solution
{
public:
vector<vector<int>> res;
vector<vector<int>> pathSum(TreeNode* root, int sum)
{
vector<int> one;
bydfs(root,one, 0, sum);
return res;
}

void bydfs(TreeNode* root, vector<int> one, int a, int sum)
{
if (root == NULL)
return ;
else
{
one.push_back(root->val);
if (root->left == NULL && root->right == NULL)
{
if (a + root->val == sum)
res.push_back(one);
else
return;
}
else
{
bydfs(root->left,one, a + root->val, sum);
bydfs(root->right,one, a + root->val, sum);
}
one.erase(one.end() - 1);
}
}
};

4000