refactor 347

fishercoder1534 · fishercoder1534 · commit fce2b1f21eac · 2020-07-17T06:37:54.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_347.java b/src/main/java/com/fishercoder/solutions/_347.java
@@ -15,7 +15,7 @@ public static class Solution1 {
          * Use buckets to hold numbers of the same frequency
          * It's averaged at 30 ms on Leetcode.
          */
-        public List<Integer> topKFrequent(int[] nums, int k) {
+        public int[] topKFrequent(int[] nums, int k) {
             Map<Integer, Integer> map = new HashMap();
             for (int i : nums) {
                 map.put(i, map.getOrDefault(i, 0) + 1);
@@ -37,16 +37,19 @@ public List<Integer> topKFrequent(int[] nums, int k) {
                     }
                 }
             }
-
-            return result;
+            int[] arr = new int[result.size()];
+            for (int i = 0; i < arr.length; i++) {
+                arr[i] = result.get(i);
+            }
+            return arr;
         }
     }
 
     public static class Solution2 {
         /**
          * Use hashtable and heap, it's averaged at 100 ms on Leetocde.
          */
-        public List<Integer> topKFrequent(int[] nums, int k) {
+        public int[] topKFrequent(int[] nums, int k) {
             // construct the frequency map first, and then iterate through the map
             // and put them into the heap, this is O(n)
             Map<Integer, Integer> map = new HashMap();
@@ -60,11 +63,15 @@ public List<Integer> topKFrequent(int[] nums, int k) {
                 heap.offer(entry);
             }
 
-            List<Integer> res = new ArrayList();
+            List<Integer> result = new ArrayList();
             while (k-- > 0) {
-                res.add(heap.poll().getKey());
+                result.add(heap.poll().getKey());
+            }
+            int[] arr = new int[result.size()];
+            for (int i = 0; i < arr.length; i++) {
+                arr[i] = result.get(i);
             }
-            return res;
+            return arr;
         }
     }
 }
diff --git a/src/test/java/com/fishercoder/_347Test.java b/src/test/java/com/fishercoder/_347Test.java
@@ -4,17 +4,13 @@
 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;
+import static org.junit.Assert.assertArrayEquals;
 
 public class _347Test {
     private static _347.Solution1 solution1;
     private static _347.Solution2 solution2;
     private static int[] nums;
-    private static List<Integer> expected;
+    private static int[] expected;
 
     @BeforeClass
     public static void setup() {
@@ -25,26 +21,26 @@ public static void setup() {
     @Test
     public void test1() {
         nums = new int[]{3, 0, 1, 0};
-        expected = new ArrayList<>(Arrays.asList(0, 3));
+        expected = new int[]{0, 3};
         /**Comment out until Leetcode addresses this test case:
          * https://discuss.leetcode.com/topic/44237/java-o-n-solution-bucket-sort/75
          * Then I'll update this Solution1 code accordingly.
          *
          * My post is still un-addressed. - 3/12/2018*/
-        //assertEquals(expected, solution1.topKFrequent(nums, 2));
+        //assertArrayEquals(expected, solution1.topKFrequent(nums, 2));
     }
 
     @Test
     public void test2() {
         nums = new int[]{3, 0, 1, 0};
-        expected = new ArrayList<>(Arrays.asList(0, 3));
-        assertEquals(expected, solution2.topKFrequent(nums, 2));
+        expected = new int[]{0, 3};
+        assertArrayEquals(expected, solution2.topKFrequent(nums, 2));
     }
 
     @Test
     public void test3() {
-        nums = new int[] {1, 1, 1, 2, 2, 3};
-        expected = new ArrayList<>(Arrays.asList(1, 2));
-        assertEquals(expected, solution1.topKFrequent(nums, 2));
+        nums = new int[]{1, 1, 1, 2, 2, 3};
+        expected = new int[]{1, 2};
+        assertArrayEquals(expected, solution1.topKFrequent(nums, 2));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public static class Solution1 {`
`15`	`15`	`* Use buckets to hold numbers of the same frequency`
`16`	`16`	`* It's averaged at 30 ms on Leetcode.`
`17`	`17`	`*/`
`18`		`- public List<Integer> topKFrequent(int[] nums, int k) {`
	`18`	`+ public int[] topKFrequent(int[] nums, int k) {`
`19`	`19`	`Map<Integer, Integer> map = new HashMap();`
`20`	`20`	`for (int i : nums) {`
`21`	`21`	`map.put(i, map.getOrDefault(i, 0) + 1);`
`@@ -37,16 +37,19 @@ public List<Integer> topKFrequent(int[] nums, int k) {`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`	`}`
`40`		`-`
`41`		`- return result;`
	`40`	`+ int[] arr = new int[result.size()];`
	`41`	`+ for (int i = 0; i < arr.length; i++) {`
	`42`	`+ arr[i] = result.get(i);`
	`43`	`+ }`
	`44`	`+ return arr;`
`42`	`45`	`}`
`43`	`46`	`}`
`44`	`47`
`45`	`48`	`public static class Solution2 {`
`46`	`49`	`/**`
`47`	`50`	`* Use hashtable and heap, it's averaged at 100 ms on Leetocde.`
`48`	`51`	`*/`
`49`		`- public List<Integer> topKFrequent(int[] nums, int k) {`
	`52`	`+ public int[] topKFrequent(int[] nums, int k) {`
`50`	`53`	`// construct the frequency map first, and then iterate through the map`
`51`	`54`	`// and put them into the heap, this is O(n)`
`52`	`55`	`Map<Integer, Integer> map = new HashMap();`
`@@ -60,11 +63,15 @@ public List<Integer> topKFrequent(int[] nums, int k) {`
`60`	`63`	`heap.offer(entry);`
`61`	`64`	`}`
`62`	`65`
`63`		`- List<Integer> res = new ArrayList();`
	`66`	`+ List<Integer> result = new ArrayList();`
`64`	`67`	`while (k-- > 0) {`
`65`		`- res.add(heap.poll().getKey());`
	`68`	`+ result.add(heap.poll().getKey());`
	`69`	`+ }`
	`70`	`+ int[] arr = new int[result.size()];`
	`71`	`+ for (int i = 0; i < arr.length; i++) {`
	`72`	`+ arr[i] = result.get(i);`
`66`	`73`	`}`
`67`		`- return res;`
	`74`	`+ return arr;`
`68`	`75`	`}`
`69`	`76`	`}`
`70`	`77`	`}`