refactor 113

fishercoder1534 · fishercoder1534 · commit a764c7120bef · 2018-03-27T07:29:13.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_113.java b/src/main/java/com/fishercoder/solutions/_113.java
@@ -5,8 +5,10 @@
 import java.util.ArrayList;
 import java.util.List;
 
-/**113. 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.
+/**
+ * 113. 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,
@@ -17,38 +19,40 @@
           11  13  4
          /  \    / \
         7    2  5   1
-return
+
+ return
 [
    [5,4,11,2],
    [5,8,4,5]
 ]
 */
 public class _113 {
 
+  public static class Solution1 {
     public List<List<Integer>> pathSum(TreeNode root, int sum) {
-        List<List<Integer>> allPaths = new ArrayList();
-        if (root == null) {
-            return allPaths;
-        }
-        dfs(root, new ArrayList(), allPaths, sum);
+      List<List<Integer>> allPaths = new ArrayList();
+      if (root == null) {
         return allPaths;
+      }
+      dfs(root, new ArrayList(), allPaths, sum);
+      return allPaths;
     }
 
-
     private void dfs(TreeNode root, List<Integer> path, List<List<Integer>> allPaths, int sum) {
-        path.add(root.val);
-        if (root.left != null) {
-            dfs(root.left, path, allPaths, sum - root.val);
-        }
-        if (root.right != null) {
-            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) {
-                allPaths.add(new ArrayList(path));
-            }
+      path.add(root.val);
+      if (root.left != null) {
+        dfs(root.left, path, allPaths, sum - root.val);
+      }
+      if (root.right != null) {
+        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) {
+          allPaths.add(new ArrayList(path));
         }
-        path.remove(path.size() - 1);
+      }
+      path.remove(path.size() - 1);
     }
-}
+  }
+}
diff --git a/src/test/java/com/fishercoder/_113Test.java b/src/test/java/com/fishercoder/_113Test.java
@@ -13,25 +13,24 @@
 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;
+  private static _113.Solution1 solution1;
+  private static TreeNode root;
+  private static int sum;
+  private static List<List<Integer>> expected;
 
-    @BeforeClass
-    public static void setup() {
-        test = new _113();
-    }
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _113.Solution1();
+  }
 
-    @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));
-    }
-
-}
+  @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, solution1.pathSum(root, sum));
+  }
+}
