[N-0] refactor 501

Author: fishercoder1534

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

@@ -11,12 +11,13 @@
 
 
 /**
- Given a binary search tree with duplicates. You have to find all the mode(s) in given binary tree.
+ * 501. Find Mode in Binary Search Tree
+ * Given a binary search tree with duplicates. You have to find all the mode(s) in given binary tree.
 
  For example:
  Given binary tree [1,null,2,2],
- 1
-  \
+  1
+   \
    2
   /
  2
@@ -27,50 +28,83 @@ Given a binary search tree with duplicates. You have to find all the mode(s) in
  */
 public class _501 {
 
-    public int[] findMode(TreeNode root) {
-        int[] result = new int[]{};
-        Map<Integer, Integer> map = new HashMap();
-        if (root == null) {
+    public static class Solution1 {
+        public int[] findMode(TreeNode root) {
+            int[] result = new int[]{};
+            Map<Integer, Integer> map = new HashMap();
+            if (root == null) {
+                return result;
+            }
+            List<Integer> list = bfs(root, map);
+            result = new int[list.size()];
+            for (int i = 0; i < list.size(); i++) {
+                result[i] = list.get(i);
+            }
             return result;
         }
-        List<Integer> list = bfs(root, map);
-        result = new int[list.size()];
-        for (int i = 0; i < list.size(); i++) {
-            result[i] = list.get(i);
-        }
-        return result;
-    }
 
-    private List<Integer> bfs(TreeNode root, Map<Integer, Integer> map) {
-        Queue<TreeNode> queue = new LinkedList<>();
-        queue.offer(root);
-        while (!queue.isEmpty()) {
-            int size = queue.size();
-            for (int i = 0; i < size; i++) {
-                TreeNode treeNode = queue.poll();
-                if (treeNode.left != null) {
-                    queue.offer(treeNode.left);
+        private List<Integer> bfs(TreeNode root, Map<Integer, Integer> map) {
+            Queue<TreeNode> queue = new LinkedList<>();
+            queue.offer(root);
+            while (!queue.isEmpty()) {
+                int size = queue.size();
+                for (int i = 0; i < size; i++) {
+                    TreeNode treeNode = queue.poll();
+                    if (treeNode.left != null) {
+                        queue.offer(treeNode.left);
+                    }
+                    if (treeNode.right != null) {
+                        queue.offer(treeNode.right);
+                    }
+                    map.put(treeNode.val, map.getOrDefault(treeNode.val, 0) + 1);
                 }
-                if (treeNode.right != null) {
-                    queue.offer(treeNode.right);
+            }
+
+            int highestFrequency = 0;
+            List<Integer> list = new ArrayList<>();
+            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
+                if (entry.getValue() > highestFrequency) {
+                    highestFrequency = entry.getValue();
+                    list.clear();
+                    list.add(entry.getKey());
+                } else if (entry.getValue() == highestFrequency) {
+                    list.add(entry.getKey());
                 }
-                map.put(treeNode.val, map.getOrDefault(treeNode.val, 0) + 1);
             }
+
+            return list;
         }
+    }
 
-        int highestFrequency = 0;
-        List<Integer> list = new ArrayList<>();
-        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
-            if (entry.getValue() > highestFrequency) {
-                highestFrequency = entry.getValue();
-                list.clear();
-                list.add(entry.getKey());
-            } else if (entry.getValue() == highestFrequency) {
-                list.add(entry.getKey());
+    public static class Solution2 {
+        public int[] findMode(TreeNode root) {
+            Map<Integer, Integer> map = new HashMap<>();
+            dfs(root, map);
+            int modeCount = 0;
+            for (int key : map.keySet()) {
+                modeCount = Math.max(modeCount, map.get(key));
+            }
+            List<Integer> mode = new ArrayList<>();
+            for (int key : map.keySet()) {
+                if (map.get(key) == modeCount) {
+                    mode.add(key);
+                }
+            }
+            int[] result = new int[mode.size()];
+            for (int i = 0; i < mode.size(); i++) {
+                result[i] = mode.get(i);
             }
+            return result;
         }
 
-        return list;
+        private void dfs(TreeNode root, Map<Integer, Integer> map) {
+            if (root == null) {
+                return;
+            }
+            dfs(root.left, map);
+            map.put(root.val, map.getOrDefault(root.val, 0) + 1);
+            dfs(root.right, map);
+        }
     }
 
 }

src/test/java/com/fishercoder/_501Test.java

@@ -13,14 +13,16 @@
  * Created by fishercoder on 1/28/17.
  */
 public class _501Test {
-    private static _501 test;
+    private static _501.Solution1 solution1;
+    private static _501.Solution2 solution2;
     private static int[] expected;
     private static int[] actual;
     private static TreeNode treeNode;
 
     @BeforeClass
     public static void setup() {
-        test = new _501();
+        solution1 = new _501.Solution1();
+        solution2 = new _501.Solution2();
     }
 
     @Before
@@ -32,15 +34,16 @@ public void setupForEachTest() {
 
     @Test
     public void test1() {
-
         treeNode = new TreeNode(1);
         treeNode.right = new TreeNode(2);
         treeNode.right.left = new TreeNode(2);
         expected = new int[]{2};
         CommonUtils.printArray(expected);
         CommonUtils.printArray(actual);
-        actual = test.findMode(treeNode);
+        actual = solution1.findMode(treeNode);
         assertArrayEquals(expected, actual);
 
+        actual = solution2.findMode(treeNode);
+        assertArrayEquals(expected, actual);
     }
 }