hashmap priorityqueue(max-heap) bucket sort medium good try array

Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order.

 

Example 1:

Input: nums = [1,1,1,2,2,3], k = 2
Output: [1,2]
Example 2:

Input: nums = [1], k = 1
Output: [1]
 

Constraints:

1 <= nums.length <= 105
-104 <= nums[i] <= 104
k is in the range [1, the number of unique elements in the array].
It is guaranteed that the answer is unique.
 

Follow up: Your algorithm's time complexity must be better than O(n log n), where n is the array's size.

Seen this question in a real interview before?
1/5
Yes
No
Accepted
2.4M
Submissions
3.8M
Acceptance Rate
63.6%
Topics
Array
Hash Table
Divide and Conquer
Sorting
Heap (Priority Queue)
Bucket Sort
Counting
Quickselect

Author: Gauranshgoel123

top-k-frequent-elements.java

@@ -0,0 +1,95 @@
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer, Integer> counter = new HashMap<>();
+        for (int n : nums) {
+            counter.put(n, counter.getOrDefault(n, 0) + 1);
+        }
+        
+        List<Integer>[] freq = new ArrayList[nums.length + 1];
+        for (int i = 0; i < freq.length; i++) {
+            freq[i] = new ArrayList<>();
+        }
+        /*An array of List<Integer> called freq is created with nums.length + 1 buckets.
+        Each index i in freq represents a list of numbers that appear i times in nums.
+        The length of nums + 1 ensures that we can represent frequencies from 0 to nums.length (the maximum possible frequency).*/
+
+        for (Map.Entry<Integer, Integer> entry : counter.entrySet()) {
+            int frequency = entry.getValue();
+            freq[frequency].add(entry.getKey());
+        }
+        //Populate the Bucket Array
+        //Iterate over the entries in the counter map. For each entry, add the key (the number) to the list at the index corresponding to its frequency in freq.
+        
+        int[] res = new int[k];
+        int idx = 0;
+        for (int i = freq.length - 1; i >= 0; i--) {
+            for (int num : freq[i]) {
+                res[idx++] = num;
+                if (idx == k) {
+                    return res;
+                }
+            }
+        }
+        /* Start iterating from the end of freq (the highest possible frequency) down to 0.
+        For each non-empty bucket, add the elements to res until k elements have been collected.
+        If idx reaches k, return the res array. */
+                
+        return new int[0];        
+    }
+}
+
+
+
+
+
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer, Integer> counter = new HashMap<>();
+        for (int n : nums) {
+            counter.put(n, counter.getOrDefault(n, 0) + 1);
+        }
+        
+        PriorityQueue<Map.Entry<Integer, Integer>> heap = new PriorityQueue<>(
+            (a, b) -> Integer.compare(b.getValue(), a.getValue())
+        );
+        //A PriorityQueue named heap is created to act as a max heap based on the frequency of the elements.
+        //The comparator (a, b) -> Integer.compare(b.getValue(), a.getValue()) ensures that entries with higher frequencies are given higher priority, making it a max heap.
+        
+        for (Map.Entry<Integer, Integer> entry : counter.entrySet()) {
+            heap.offer(entry);
+        }
+        //Each entry from the counter map is added to the heap. The heap will order the entries such that the element with the highest frequency is at the top.
+        
+        int[] res = new int[k];
+        for (int i = 0; i < k; i++) {
+            res[i] = Objects.requireNonNull(heap.poll()).getKey();
+        }
+        //The heap.poll() method retrieves and removes the element at the top of the heap (i.e., the element with the highest frequency). The getKey() method extracts the number, which is added to res.
+        //Objects.requireNonNull() ensures that poll() does not return null, adding a layer of safety.
+        return res;        
+    }
+}
+
+
+
+
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer, Integer> frequencyMap = new HashMap<>();
+        
+        for (int n : nums) {
+            frequencyMap.put(n, frequencyMap.getOrDefault(n, 0) + 1);
+        }
+        
+        List<Map.Entry<Integer, Integer>> entryList = new ArrayList<>(frequencyMap.entrySet());
+        
+        Collections.sort(entryList, (a, b) -> b.getValue()- a.getValue());
+        
+        int[] result = new int[k];
+        for (int i = 0; i < k; i++) {
+            result[i] = entryList.get(i).getKey();
+        }
+        
+        return result;
+    }
+}