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. DFS algo.

Iterative? 

/**
 * 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>> result = new ArrayList<ArrayList<Integer>>();
        ArrayList<ArrayList<Integer>> lres = new ArrayList<ArrayList<Integer>>();
        ArrayList<ArrayList<Integer>> rres = new ArrayList<ArrayList<Integer>>();
        
        if(root == null) {
            return result;
        }
        
        sum -= root.val;
        if(sum == 0 && root.left == null && root.right == null) {   // return an ArrayList contains current node if success
            result.add(new ArrayList<Integer>());
            result.get(result.size()-1).add(root.val);
            return result;
        }
        else if(root.left == null && root.right == null) {          // return empty ArrayList if failed
            return result;
        }
        
        // left subtree
        if(root.left != null) {
            lres = pathSum(root.left, sum);
            if(!lres.isEmpty()) {
                for(int i=0; i<lres.size(); i++) {
                    result.add(new ArrayList<Integer>());
                    result.get(result.size()-1).add(root.val);
                    result.get(result.size()-1).addAll(lres.get(i));
                }
            }
        }
        
        // right subtree
        if(root.right != null) {
            rres = pathSum(root.right, sum);
            if(!rres.isEmpty()) {
                for(int i=0; i<rres.size(); i++) {
                    result.add(new ArrayList<Integer>());
                    result.get(result.size()-1).add(root.val);
                    result.get(result.size()-1).addAll(rres.get(i));
                }
            }
        }
        
        return result;
    }
}

Update 02/06/2014: 

Analysis: We need to find root-to-leaf paths, so how do we know a node is a leaf? A leaf has no child, which is leaf.left==null && leaf.right==null. Therefore, a qualified path should satisfied that root.left==null && root.right==null && sum-root.val==0. The algorithms used here are dfs and backtracking. 

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void pathSum(TreeNode root, int sum, ArrayList<ArrayList<Integer>> res, ArrayList<Integer> tem) {
        if(root==null) return;
        if(root.left==null && root.right==null && sum-root.val==0) {
            ArrayList<Integer> clone = new ArrayList<Integer>(tem);
            clone.add(root.val);
            res.add(clone);
            return;
        }

        tem.add(root.val);
        pathSum(root.left, sum-root.val, res, tem);
        pathSum(root.right, sum-root.val, res, tem);
        tem.remove(tem.size()-1);
        return;
    }
    
    public ArrayList<ArrayList<Integer>> pathSum(TreeNode root, int sum) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> tem = new ArrayList<Integer>();
        pathSum(root, sum, res, tem);
        return res;
    }
}