例如,给定以下二叉树:
[2,3,5,4,8,6,-2,null,null,null,null,null,null,null,2]和sum = 7
2
/ \
3 5
/ \ / \
4 8 6 -2
\
2
打印:[3,4],[2,5],[2,5,-2,2]
我可以提出一个n ^ 2解决方案,但有更好的解决方案吗?也许有一些额外的内存,比如使用堆栈或哈希表。
我花了4个小时尝试提出一些解决方案,但所有解决方案都变得太丑陋或混乱。
我的n ^ 2解决方案相对简单: 1)有一种方法,即帮助,它递归地调用自己直到所有的叶子。当它找到带和的路径时,将其添加到结果中。 (这将需要O(n)) 2)为树中的每个节点调用此方法(O(n)* O(n)= O(n ^ 2))
我的简单解决方案
//TreeNode structure
public class TreeNode {
int val;
public TreeNode left;
public TreeNode right;
TreeNode(int x) { val = x; }
}
//Solution class
public class Solution {
public List<List<Integer>> pathSum(TreeNode root, int sum) {
List<Integer> temp = new ArrayList<Integer>();
List<List<Integer>> result = new ArrayList<>();
if (root == null) return result;
Queue<TreeNode> q = new LinkedList<>();
q.offer(root);
while ( !q.isEmpty())
{
TreeNode top = q.poll();
helper(top,sum,temp,result);
if (top.left != null) q.offer(top.left);
if (top.right != null) q.offer(top.right);
}
return result;
}
public void helper(TreeNode root, int sum, List<Integer> temp, List<List<Integer>> result)
{
if (root == null) return;
temp.add(root.val) ;
if (root.val == sum)
{
result.add(new ArrayList<>(temp));
}
helper(root.left,sum-root.val, temp, result );
helper(root.right, sum-root.val, temp, result);
temp.remove(temp.size() - 1);
}
}
//Execution class
public class treeApp {
public static void main(String args[])
{ TreeNode root = new TreeNode(2);
root.left = new TreeNode(3);
root.right = new TreeNode(5);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(8);
root.right.left = new TreeNode(6);
root.right.right = new TreeNode(-2);
root.right.right.right = new TreeNode(2);
Solution sol = new Solution();
List<List<Integer>> result ;
result = sol.pathSum(root, 7);
for (List l : result)
{
System.out.println(l.toString());
}
}
//Prints:
[2, 5]
[2, 5, -2, 2]
[3, 4]
答案 0 :(得分:0)
以任何方便的方式遍历树(广度优先或深度优先),但包括此节点的路径。
在每个节点上,检查在此节点结束的所有路径总和;如果有任何等于目标值,请将这些路径添加到解决方案中(作为功能结果传回)。
然后重复:将当前节点添加到路径并调用每个子节点。
这是否足够清楚?我认为这可以在更短的时间内解决问题。遍历是O(N)以到达所有节点。在每个节点,您将遍历路径,该路径长度很长。如果您有一个平衡的二叉树,则深度为O(log2 [N])。