[leet code] 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]
]

==============

Analysis:

1. Recursive approach, each recursive call focus on one node.

for each recursive call:

2. add current node value to sum of the current path and add node value into int array list of current path.

3. if leaf reached, compare sum of current path with target sum. 

4. If current node is not leaf, then check its left subtree and right subtree.

Recursive function exit: current node == null or leaf reached 

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ArrayList<ArrayList<Integer>> pathSum(TreeNode root, int sum) {
        ArrayList<ArrayList<Integer>> paths = new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> singlePath = new ArrayList<Integer>();
        helper(root, sum, paths, singlePath, 0);
        return paths;
    }
    
    public void helper(TreeNode node, int sum, ArrayList<ArrayList<Integer>> paths, ArrayList<Integer> singlePath, int tempSum){
        if (node == null) return;
        
        tempSum+=node.val;
        singlePath.add(node.val);
        
        if(node.left==null&&node.right==null) {// reached the leaf
            if(tempSum==sum) paths.add(new ArrayList<Integer>(singlePath));
            singlePath.remove(singlePath.size()-1);
            return;  
        }
        
        helper(node.left, sum, paths, singlePath, tempSum);
        helper(node.right, sum, paths, singlePath, tempSum);
        singlePath.remove(singlePath.size()-1);
    }
}

Note: remove the last element of the array list of current path before return in recursive function.