Find ALL the paths in a binary tree equal to a sum - algorithm

Question

For example, given the following binary tree:
[2,3,5,4,8,6,-2,null,null,null,null,null,null,null,2] and sum = 7
2
/ \
3 5
/ \ / \
4 8 6 -2
\
2
Print : [3,4] , [2,5] , [2,5,-2,2]
I could come up with a n^2 solution, but is there a better solution to it? Maybe with a some extra memory, like using a stack or hashtable.
I've spent 4 hours trying to come up with some solution, but all the solution becomes too ugly or chaotic.
My n^2 solution is relatively simple:
1) Have one method i.e. helper which recursively calls itself till all the leafs. When it finds a path with the sum, add it to the result. (This is will take O(n))
2)Call this method for every node in the tree ( O(n) * O(n) = O(n^2))
My simple solution
//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]

Answer 1

Traverse the tree in any convenient fashion (breadth-first or depth-first), but include the path to this node.
At each node, check all of the path sums that end at this node; if any equal the target value, add those paths to the solution (passed back as the functional result).
Then recur: add the current node to the path and call on each child.
Is this clear enough? I think this solves the problem in less time. The traversal is O(N) to reach all the nodes. At each node, you walk through the path, which is of length . If you have a balanced binary tree, the depth is O(log2[N]).