refactor 662

fishercoder1534 · fishercoder1534 · commit 79c5614a7a4a · 2019-09-03T07:56:00.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_662.java b/src/main/java/com/fishercoder/solutions/_662.java
@@ -9,7 +9,6 @@
 import java.util.Map;
 import java.util.Queue;
 
-
 /**
  * 662. Maximum Width of Binary Tree
  *
@@ -72,38 +71,40 @@
  Note: Answer will in the range of 32-bit signed integer.
  */
 public class _662 {
-    /**
-     * Use a map to store the node to value map,
-     * we use root as index 1, then its left child is 2*i-1 and right child is 2*i
-     */
-    public int widthOfBinaryTree(TreeNode root) {
-        if (root == null) {
-            return 0;
-        }
+    public static class Solution1 {
+        /**
+         * Use a map to store the node to value map,
+         * we use root as index 1, then its left child is 2*i-1 and right child is 2*i
+         */
+        public int widthOfBinaryTree(TreeNode root) {
+            if (root == null) {
+                return 0;
+            }
 
-        Queue<Map.Entry<TreeNode, Integer>> queue = new LinkedList<>();
-        queue.offer(new AbstractMap.SimpleEntry<>(root, 1));
-        int max = 1;
-        while (!queue.isEmpty()) {
-            int size = queue.size();
-            List<Map.Entry<TreeNode, Integer>> list = new ArrayList<>();
-            for (int i = 0; i < size; i++) {
-                Map.Entry<TreeNode, Integer> curr = queue.poll();
-                if (curr.getKey().left != null) {
-                    Map.Entry<TreeNode, Integer> newEntry = new AbstractMap.SimpleEntry<>(curr.getKey().left, curr.getValue() * 2 - 1);
-                    queue.offer(newEntry);
-                    list.add(newEntry);
+            Queue<Map.Entry<TreeNode, Integer>> queue = new LinkedList<>();
+            queue.offer(new AbstractMap.SimpleEntry<>(root, 1));
+            int max = 1;
+            while (!queue.isEmpty()) {
+                int size = queue.size();
+                List<Map.Entry<TreeNode, Integer>> list = new ArrayList<>();
+                for (int i = 0; i < size; i++) {
+                    Map.Entry<TreeNode, Integer> curr = queue.poll();
+                    if (curr.getKey().left != null) {
+                        Map.Entry<TreeNode, Integer> newEntry = new AbstractMap.SimpleEntry<>(curr.getKey().left, curr.getValue() * 2 - 1);
+                        queue.offer(newEntry);
+                        list.add(newEntry);
+                    }
+                    if (curr.getKey().right != null) {
+                        Map.Entry<TreeNode, Integer> newEntry = new AbstractMap.SimpleEntry<>(curr.getKey().right, curr.getValue() * 2);
+                        queue.offer(newEntry);
+                        list.add(newEntry);
+                    }
                 }
-                if (curr.getKey().right != null) {
-                    Map.Entry<TreeNode, Integer> newEntry = new AbstractMap.SimpleEntry<>(curr.getKey().right, curr.getValue() * 2);
-                    queue.offer(newEntry);
-                    list.add(newEntry);
+                if (list.size() > 1) {
+                    max = Math.max(list.get(list.size() - 1).getValue() - list.get(0).getValue() + 1, max);
                 }
             }
-            if (list.size() > 1) {
-                max = Math.max(list.get(list.size() - 1).getValue() - list.get(0).getValue() + 1, max);
-            }
+            return max;
         }
-        return max;
     }
 }
diff --git a/src/test/java/com/fishercoder/_662Test.java b/src/test/java/com/fishercoder/_662Test.java
@@ -12,34 +12,34 @@
 import static junit.framework.TestCase.assertEquals;
 
 public class _662Test {
-    private static _662 test;
+    private static _662.Solution1 solution1;
     private static TreeNode root;
     private static int expected;
 
     @BeforeClass
     public static void setup() {
-        test = new _662();
+        solution1 = new _662.Solution1();
     }
 
     @Test
     public void test1() {
         root = TreeUtils.constructBinaryTree(Arrays.asList(1, 3, 2, 5, 3, null, 9));
         expected = 4;
-        assertEquals(expected, test.widthOfBinaryTree(root));
+        assertEquals(expected, solution1.widthOfBinaryTree(root));
     }
 
     @Test
     public void test2() {
         root = TreeUtils.constructBinaryTree(Arrays.asList(1, 3, null, 5, 3));
         expected = 2;
-        assertEquals(expected, test.widthOfBinaryTree(root));
+        assertEquals(expected, solution1.widthOfBinaryTree(root));
     }
 
     @Test
     public void test3() {
         root = TreeUtils.constructBinaryTree(Arrays.asList(1, 3, 2, 5));
         expected = 2;
-        assertEquals(expected, test.widthOfBinaryTree(root));
+        assertEquals(expected, solution1.widthOfBinaryTree(root));
     }
 
     @Test
@@ -48,13 +48,13 @@ public void test3() {
     public void test4() {
         root = TreeUtils.constructBinaryTree(Arrays.asList(1, 3, 2, 5, null, null, 9, 6, null, null, null, null, null, null, 7));
         expected = 8;
-        assertEquals(expected, test.widthOfBinaryTree(root));
+        assertEquals(expected, solution1.widthOfBinaryTree(root));
     }
 
     @Test
     public void test5() {
         root = TreeUtils.constructBinaryTree(Arrays.asList(1));
         expected = 1;
-        assertEquals(expected, test.widthOfBinaryTree(root));
+        assertEquals(expected, solution1.widthOfBinaryTree(root));
     }
 }
