JavaScript Program to Find k Most Occurrences in the Given Array
K most occurrences in an array refer to finding the K unique elements that appear the most frequently within the given array, where K is a specified integer. These are the elements with the highest frequencies in the array.
Example:
Input: arr[] = {3, 1, 4, 4, 5, 2, 6, 1}, K = 2
Output: 4 1
Explanation:
Frequency of 4 = 2, Frequency of 1 = 2
These two have the maximum frequency and 4 is larger than 1.
refer
Input: arr[] = {7, 10, 11, 5, 2, 5, 5, 7, 11, 8, 9}, K = 4
Output: 5 11 7 10
Explanation:
Frequency of 5 = 3, Frequency of 11 = 2, Frequency of 7 = 2, Frequency of 10 = 1
These four have the maximum frequency and 5 is largest among rest.
Approach 1: Using map() method
In This approach we are using the map() method to count the occurrences of elements in an array, creating a frequency map. It then converts this map into an array of [element, frequency] pairs, sorts them by frequency in descending order, and finally, extracts the top k elements, providing an efficient solution for finding k most occurring elements.
Syntax:
map((element) => { /* … */ })Example: Below is the implementation of the above approach.
function frequentElements(arr, k) {
const frequencyMap = new Map();
// Count the occurrences of
// each element in the array
for (let i = 0; i < arr.length; i++) {
const num = arr[i];
frequencyMap.has(num)
? frequencyMap.
set(num, frequencyMap.get(num) + 1)
: frequencyMap.set(num, 1);
}
// Sort the entries in the frequency
// map by frequency in descending order
const sortedEntries =
[...frequencyMap.entries()]
.sort((a, b) => b[1] - a[1]);
const result = [];
// Extract the first k elements
// from the sorted entries
for (let i = 0; i < k &&
i < sortedEntries.length; i++) {
result.push(sortedEntries[i][0]);
}
return result;
}
const arr = [3, 1, 4, 4, 5, 2, 6, 1];
const k = 2;
const kMostFrequent = frequentElements(arr, k);
console.log(...kMostFrequent);
Output
1 4
Approach 2: Using reduce() with sort() method
In This approach uses the reduce() method to create a frequency map of elements in the array, followed by sorting the map entries using sort(). Finally, it extracts the top k elements from the sorted entries to find the k most frequent elements.
Syntax:
array.reduce( function(total, currentValue, currentIndex, arr),
initialValue )
Example: Below is the implementation of the above approach.
function frequentElements(arr, k) {
const frequencyMap =
arr.reduce((map, num) => {
map.set(num, (map.get(num) || 0) + 1);
return map;
}, new Map());
// Sort the entries in the frequency
// map by frequency in descending order
const sortedEntries =
[...frequencyMap.entries()]
.sort((a, b) => b[1] - a[1]);
const result = [];
for (const [element, _] of
sortedEntries.slice(0, k)) {
result.push(element);
}
return result;
}
const arr = [3, 1, 4, 4, 5, 2, 6, 1];
const k = 2;
const kMostFrequent =
frequentElements(arr, k);
console.log(...kMostFrequent);
Output
1 4
Approach 3: Using a Min-Heap (Priority Queue)
In this approach, we use a min-heap to efficiently find the K most frequent elements in the array. A min-heap allows us to keep track of the top K elements with the highest frequencies while ensuring that the heap size never exceeds K. This method is particularly efficient when K is much smaller than the number of unique elements in the array.
Example:
function topKFrequentElements(arr, K) {
// Step 1: Create a frequency map
const freqMap = new Map();
for (let num of arr) {
freqMap.set(num, (freqMap.get(num) || 0) + 1);
}
// Step 2: Use a min-heap to track top K elements
const minHeap = new MinHeap();
for (let [num, freq] of freqMap) {
minHeap.insert([freq, num]);
if (minHeap.size() > K) {
minHeap.remove();
}
}
// Step 3: Extract elements from the min-heap
const result = [];
while (minHeap.size() > 0) {
result.push(minHeap.remove()[1]);
}
// The result array will contain the K most frequent elements
return result.reverse(); // To get the elements in descending order of frequency
}
// MinHeap class implementation
class MinHeap {
constructor() {
this.heap = [];
}
size() {
return this.heap.length;
}
insert(value) {
this.heap.push(value);
this._heapifyUp();
}
remove() {
const root = this.heap[0];
const end = this.heap.pop();
if (this.heap.length > 0) {
this.heap[0] = end;
this._heapifyDown();
}
return root;
}
_heapifyUp() {
let index = this.heap.length - 1;
while (index > 0) {
const parentIndex = Math.floor((index - 1) / 2);
if (this.heap[index][0] >= this.heap[parentIndex][0]) break;
[this.heap[index], this.heap[parentIndex]] = [this.heap[parentIndex], this.heap[index]];
index = parentIndex;
}
}
_heapifyDown() {
let index = 0;
const length = this.heap.length;
const element = this.heap[0];
while (true) {
const leftChildIndex = 2 * index + 1;
const rightChildIndex = 2 * index + 2;
let leftChild, rightChild;
let swap = null;
if (leftChildIndex < length) {
leftChild = this.heap[leftChildIndex];
if (leftChild[0] < element[0]) {
swap = leftChildIndex;
}
}
if (rightChildIndex < length) {
rightChild = this.heap[rightChildIndex];
if ((swap === null && rightChild[0] < element[0]) || (swap !== null && rightChild[0] < leftChild[0])) {
swap = rightChildIndex;
}
}
if (swap === null) break;
[this.heap[index], this.heap[swap]] = [this.heap[swap], this.heap[index]];
index = swap;
}
}
}
// Examples
const arr1 = [3, 1, 4, 4, 5, 2, 6, 1];
const K1 = 2;
console.log(topKFrequentElements(arr1, K1)); // Output: [4, 1]
const arr2 = [7, 10, 11, 5, 2, 5, 5, 7, 11, 8, 9];
const K2 = 4;
console.log(topKFrequentElements(arr2, K2)); // Output: [5, 11, 7, 10]
Output
[ 1, 4 ] [ 5, 11, 7, 9 ]
Approach 4: Using JavaScript's Map Object and Sorting
In this approach, we use JavaScript's Map object to create a frequency map of the elements in the array. We then convert this map into an array of [element, frequency] pairs, sort them based on frequency in descending order, and extract the top K elements. This approach is straightforward and leverages JavaScript's built-in data structures for efficient computation.
Example:
function kMostFrequentElements(arr, K) {
const frequencyMap = new Map();
arr.forEach(element => {
frequencyMap.set(element, (frequencyMap.get(element) || 0) + 1);
});
const sortedFrequencyArray = [...frequencyMap.entries()].sort((a, b) => b[1] - a[1]);
return sortedFrequencyArray.slice(0, K).map(entry => entry[0]);
}
let arr1 = [3, 1, 4, 4, 5, 2, 6, 1];
let K1 = 2;
console.log(kMostFrequentElements(arr1, K1));
let arr2 = [7, 10, 11, 5, 2, 5, 5, 7, 11, 8, 9];
let K2 = 4;
console.log(kMostFrequentElements(arr2, K2));
Output
[ 1, 4 ] [ 5, 7, 11, 10 ]
