LintCode Binary Tree Paths

Binary Tree Paths

Given a binary tree, return all root-to-leaf paths.

Given the following binary tree:

    1
  /   \
 2     3
  \
   5

All root-to-leaf paths are:

 [
   "1->2->5",
   "1->3"
 ]

As mentioned in the problem we want to get all root-to-leaf paths. Because all the paths need to be found and I was considering recursively finding this could be very efficently due to reducing the possibility that missing some case.

To recursively do it, three things need to be considered:

1. What is the relationship of problem of this this tree and its two subtrees?

2. Is the problem size reducing?

3. What is the base case?

So

1. the traversing done for this tree is the traversing of this node plus left tree and right tree. We need to put the node's value to a string and when the traverse is reaching the leaves and/or null values we should return.

2. yes

3. Base case is the tree is only one node or null;

 /**
  * Definition of TreeNode:
  * public class TreeNode {
  *     public int val;
  *     public TreeNode left, right;
  *     public TreeNode(int val) {
  *         this.val = val;
  *         this.left = this.right = null;
  *     }
  * }
  */
 public class Solution {
     /**
      * @param root the root of the binary tree
      * @return all root-to-leaf paths
      */
     public List<String> binaryTreePaths(TreeNode root) {
         // Write your code here
         List<String> result = new ArrayList<String>();
         if (root == null) {
             return result;
         }
         traverse(root,String.valueOf(root.val),result);
         return result;
     }

     public void traverse(TreeNode root, String path, List<String> lists) {
         if (root == null) {
             return;
         }
         if (root.left == null && root.right == null) {
             lists.add(path);
             return;
         }
         if (root.left != null) {
             traverse(root.left,path+"->"+String.valueOf(root.left.val),lists);
         }
         if (root.right != null) {
             traverse(root.right,path+"->"+String.valueOf(root.right.val),lists);
         }
     }
 }

The trick for this problem is that the string is used to store the current path values and the adding new node values should be done in the parameters in the function calls of the left and right subtrees. This is not what I was expected because it is confused to think things together but it could be something new to learn.