refactor 663

fishercoder1534 · fishercoder1534 · commit 844f0c299e4b · 2019-09-04T09:04:19.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_663.java b/src/main/java/com/fishercoder/solutions/_663.java
@@ -52,42 +52,44 @@
 
  */
 public class _663 {
-    /**
-     * The idea is that we use a map to store the sum of each node, then in the end,
-     * we check if any node has a sum that is exactly half of total sum.
-     */
-    public boolean checkEqualTree(TreeNode root) {
-        Map<TreeNode, Integer> map = new HashMap<>();
-        int totalSum = sumForEachNode(root, map);
-        if (totalSum % 2 != 0 || map.size() < 2) {
-            return false;
-        }
-        for (TreeNode key : map.keySet()) {
-            if (map.get(key) == totalSum / 2) {
-                return true;
+    public static class Solution1 {
+        /**
+         * The idea is that we use a map to store the sum of each node, then in the end,
+         * we check if any node has a sum that is exactly half of total sum.
+         */
+        public boolean checkEqualTree(TreeNode root) {
+            Map<TreeNode, Integer> map = new HashMap<>();
+            int totalSum = sumForEachNode(root, map);
+            if (totalSum % 2 != 0 || map.size() < 2) {
+                return false;
+            }
+            for (TreeNode key : map.keySet()) {
+                if (map.get(key) == totalSum / 2) {
+                    return true;
+                }
             }
+            return false;
         }
-        return false;
-    }
 
-    private int sumForEachNode(TreeNode root, Map<TreeNode, Integer> map) {
-        if (root == null) {
-            return 0;
-        }
-        if (root.left == null && root.right == null) {
-            map.put(root, root.val);
-            return root.val;
-        }
-        int leftVal = 0;
-        if (root.left != null) {
-            leftVal = sumForEachNode(root.left, map);
-        }
-        int rightVal = 0;
-        if (root.right != null) {
-            rightVal = sumForEachNode(root.right, map);
+        private int sumForEachNode(TreeNode root, Map<TreeNode, Integer> map) {
+            if (root == null) {
+                return 0;
+            }
+            if (root.left == null && root.right == null) {
+                map.put(root, root.val);
+                return root.val;
+            }
+            int leftVal = 0;
+            if (root.left != null) {
+                leftVal = sumForEachNode(root.left, map);
+            }
+            int rightVal = 0;
+            if (root.right != null) {
+                rightVal = sumForEachNode(root.right, map);
+            }
+            int val = root.val + leftVal + rightVal;
+            map.put(root, val);
+            return val;
         }
-        int val = root.val + leftVal + rightVal;
-        map.put(root, val);
-        return val;
     }
 }
diff --git a/src/test/java/com/fishercoder/_663Test.java b/src/test/java/com/fishercoder/_663Test.java
@@ -11,45 +11,45 @@
 import static org.junit.Assert.assertEquals;
 
 public class _663Test {
-    private static _663 test;
+    private static _663.Solution1 solution1;
     private static TreeNode root;
     private static boolean expected;
 
     @BeforeClass
     public static void setup() {
-        test = new _663();
+        solution1 = new _663.Solution1();
     }
 
     @Test
     public void test1() {
         root = TreeUtils.constructBinaryTree(Arrays.asList(5, 10, 10, null, null, 2, 3));
         TreeUtils.printBinaryTree(root);
         expected = true;
-        assertEquals(expected, test.checkEqualTree(root));
+        assertEquals(expected, solution1.checkEqualTree(root));
     }
 
     @Test
     public void test2() {
         root = TreeUtils.constructBinaryTree(Arrays.asList(1, 2, 10, null, null, 2, 20));
         TreeUtils.printBinaryTree(root);
         expected = false;
-        assertEquals(expected, test.checkEqualTree(root));
+        assertEquals(expected, solution1.checkEqualTree(root));
     }
 
     @Test
     public void test3() {
         root = TreeUtils.constructBinaryTree(Arrays.asList(1, null, 2, 2));
         TreeUtils.printBinaryTree(root);
         expected = false;
-        assertEquals(expected, test.checkEqualTree(root));
+        assertEquals(expected, solution1.checkEqualTree(root));
     }
 
     @Test
     public void test4() {
         root = TreeUtils.constructBinaryTree(Arrays.asList(0));
         TreeUtils.printBinaryTree(root);
         expected = false;
-        assertEquals(expected, test.checkEqualTree(root));
+        assertEquals(expected, solution1.checkEqualTree(root));
     }
 
 }
