refactor 113

Author: fishercoder1534

README.md

@@ -495,7 +495,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |116|[Populating Next Right Pointers in Each Node](https://leetcode.com/problems/populating-next-right-pointers-in-each-node/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_116.java)| O(n)|O(1) | Medium| BFS
 |115|[Distinct Subsequences](https://leetcode.com/problems/distinct-subsequences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_115.java)| O(m*n)|O(m*n) | Hard| DP
 |114|[Flatten Binary Tree to Linked List](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_114.java)| O(n)|O(h) | Medium| Tree
-|113|[Path Sum II](https://leetcode.com/problems/path-sum-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_113.java)| O(n)|O(h) | Medium| DFS
+|113|[Path Sum II](https://leetcode.com/problems/path-sum-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_113.java)| O(n)|O(h) | Medium| DFS, Backtracking
 |112|[Path Sum](https://leetcode.com/problems/path-sum/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_112.java)| O(n)|O(1) | Easy| DFS
 |111|[Minimum Depth of Binary Tree](https://leetcode.com/problems/minimum-depth-of-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_111.java)| O(n)|O(1)~O(h) | Easy| BFS, DFS
 |110|[Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_110.java)| O(n)|O(1)~O(h) | Easy| DFS

src/main/java/com/fishercoder/solutions/_113.java

@@ -1,7 +1,6 @@
 package com.fishercoder.solutions;
 
 import com.fishercoder.common.classes.TreeNode;
-import com.fishercoder.common.utils.CommonUtils;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -25,14 +24,13 @@
 ]
 */
 public class _113 {
-    //also, it's possible that a node's value could be negative, as long as the sum of root to leaf ends up to sum
+
     public List<List<Integer>> pathSum(TreeNode root, int sum) {
         List<List<Integer>> allPaths = new ArrayList();
         if (root == null) {
             return allPaths;
         }
-        List<Integer> path = new ArrayList();
-        dfs(root, path, allPaths, sum);
+        dfs(root, new ArrayList(), allPaths, sum);
         return allPaths;
     }
 
@@ -46,57 +44,11 @@ private void dfs(TreeNode root, List<Integer> path, List<List<Integer>> allPaths
             dfs(root.right, path, allPaths, sum - root.val);
         }
         if (root.left == null && root.right == null) {
+            /**Check if sum equals root.val, not sum equals zero!*/
             if (sum == root.val) {
-                List<Integer> onePath = new ArrayList(path);
-                allPaths.add(onePath);
+                allPaths.add(new ArrayList(path));
             }
         }
         path.remove(path.size() - 1);
     }
-
-
-    public static void main(String... strings) {
-        _113 test = new _113();
-//        TreeNode root = new TreeNode(1);
-//        root.left = new TreeNode(2);
-//        int sum = 1;
-
-//        TreeNode root = new TreeNode(1);
-//        root.left = new TreeNode(-2);
-//        root.left.left = new TreeNode(1);
-//        root.left.right = new TreeNode(3);
-//        root.right = new TreeNode(-3);
-//        root.right.left = new TreeNode(-2);
-//        root.left.left.left = new TreeNode(-1);
-//        int sum = 2;
-//         1
-//        / \
-//      -2   -3
-//      / \   / 
-//     1   3 -2 
-//    /      
-//   -1
-
-        TreeNode root = new TreeNode(5);
-        root.left = new TreeNode(4);
-        root.left.left = new TreeNode(11);
-        root.left.left.left = new TreeNode(7);
-        root.left.left.right = new TreeNode(2);
-        root.right = new TreeNode(8);
-        root.right.left = new TreeNode(13);
-        root.right.right = new TreeNode(4);
-        root.right.right.left = new TreeNode(5);
-        root.right.right.right = new TreeNode(1);
-        int sum = 22;
-//         5
-//        / \
-//       4   8
-//      /   / \
-//     11  13  4
-//    /  \    / \
-//   7    2  5   1
-        List<List<Integer>> res = test.pathSum(root, sum);
-        CommonUtils.printListList(res);
-    }
-
-}
+}

src/test/java/com/fishercoder/_113Test.java

@@ -0,0 +1,37 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._113;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class _113Test {
+    private static _113 test;
+    private static TreeNode root;
+    private static int sum;
+    private static List<List<Integer>> expected;
+
+    @BeforeClass
+    public static void setup() {
+        test = new _113();
+    }
+
+    @Test
+    public void test1() {
+        sum = 22;
+        root = TreeUtils.constructBinaryTree(Arrays.asList(5, 4, 8, 11, null, 13, 4, 7, 2, null, null, 5, 1));
+        TreeUtils.printBinaryTree(root);
+        expected = new ArrayList<>();
+        expected.add(Arrays.asList(5, 4, 11, 2));
+        expected.add(Arrays.asList(5, 8, 4, 5));
+        assertEquals(expected, test.pathSum(root, sum));
+    }
+
+}