test complete topKFrequent problem

Author: geegong

contains-duplicate/Geegong.java

@@ -8,73 +8,73 @@ public class Geegong {
     public int[] topKFrequent(int[] nums, int k) {
         int[] result = new int[k];
 
-        // key : key / value : count
-        Map<Integer, Integer> keyMap = new HashMap<>();
+        // key : num element in nums / value : frequency of num elements
+        Map<Integer, Integer> numMap = new HashMap<>();
 
-        // key : count / value : HashSet<Integer> keys
-        Map<Integer, HashSet<Integer>> countMap = new HashMap<>();
+        // key : frequency of num elements / value : HashSet<Integer> num elements
+        Map<Integer, HashSet<Integer>> frequencyMap = new HashMap<>();
 
-        // 가장 많이 출연한 친구
+        // most frequent numbers
         int maxCount = 0;
 
+        // initialize numMap
         for (int num : nums) {
-            int countToBePut = 0;
+            if (numMap.containsKey(num)) {
+                Integer alreadyCounted = numMap.get(num);
+                numMap.put(num, alreadyCounted + 1);
+            } else {
+                numMap.put(num, 1);
+            }
+        }
+
+
+        //numHashSetMap
+        for (int num : numMap.keySet()) {
+            int frequencyOfNum = numMap.get(num);
+            maxCount = Math.max(maxCount, frequencyOfNum);
 
-            if (keyMap.containsKey(num)) {
-                Integer alreadyCounted = keyMap.get(num);
-                countToBePut = alreadyCounted + 1;
-                keyMap.put(num, countToBePut);
+            if (frequencyMap.containsKey(frequencyOfNum)) {
+                HashSet<Integer> alreadySet = frequencyMap.get(frequencyOfNum);
+                alreadySet.add(num);
+
+                frequencyMap.put(frequencyOfNum, alreadySet);
 
-                checkCountMapAndPutCount(countMap, num, countToBePut);
             } else {
-                countToBePut = 1;
-                keyMap.put(num, countToBePut);
-                checkCountMapAndPutCount(countMap, num, countToBePut);
-            }
+                HashSet<Integer> newHashSet = new HashSet<>();
+                newHashSet.add(num);
 
-            maxCount = Math.max(maxCount, countToBePut);
+                frequencyMap.put(frequencyOfNum, newHashSet);
+            }
         }
 
 
-        // 가장 큰 숫자부터 꺼내볼까요오오오 우후
-        int kIndex=0;
-        for (int index=maxCount; index >= 0; index--) {
-            if (kIndex >= k) {
+        // maxCount 부터 decreasing
+        int resultIndex=0;
+        for(int frequency=maxCount; frequency>=0; frequency--) {
+            if (resultIndex >= result.length) {
                 return result;
             }
 
-            if (countMap.containsKey(index)) {
-                HashSet<Integer> hashNums = countMap.get(index);
-                Iterator<Integer> iterator = hashNums.iterator();
-                while(iterator.hasNext()) {
+            if (frequencyMap.containsKey(frequency)) {
+                HashSet<Integer> numElements = frequencyMap.get(frequency);
+
+                for (int numElement : numElements) {
+                    result[resultIndex] = numElement;
+                    resultIndex++;
 
-                    if (kIndex >= k) {
+
+                    if (resultIndex >= result.length) {
                         return result;
                     }
-
-                    result[kIndex] = iterator.next();
-                    kIndex++;
                 }
-
             }
-
         }
 
         return result;
-
-
     }
 
-    public void checkCountMapAndPutCount(Map<Integer, HashSet<Integer>> countMap, int key, int count) {
-        if (countMap.containsKey(count)) {
-            HashSet<Integer> already = countMap.get(count);
-            already.add(key);
-        } else {
-            HashSet<Integer> newSet = new HashSet<>();
-            newSet.add(key);
-            countMap.put(count, newSet);
-        }
-
+    public boolean checkIsFull(int[] arr, int currIndex) {
+        return currIndex >= arr.length;
     }
 
 }