Find Mode of an Array using JavaScript
To find the mode in an array with JavaScript, where the mode is the number occurring most frequently. Various approaches can be employed to find the mode, and an array may have multiple modes if multiple numbers occur with the same highest frequency.
Example:
Input:
3, 6, 4, 6, 3, 6, 6, 7 , 6, 3 , 3
Output:
6 , 3
Use the below approaches to Find Mode in an Array using JavaScript
Table of Content
- Using a Frequency Map
- Using an object
- Using Sorting
Finding Mode in an Array using a Frequency Map
In this approach, We initialize an empty object as a frequency map to track each element’s count. By iterating through the array, we update the frequency map accordingly. Then, we determine the mode by finding the element with the highest frequency in the frequency map. Finally, we return this element as the mode of the array.
Example: Implementation of Finding Mode in an Array in JavaScript using a Frequency Map
function findModes(arr) {
// Create a frequency map
const frequencyMap = {};
arr.forEach(number => {
frequencyMap[number] =
(frequencyMap[number] || 0) + 1;
});
let modes = [];
let maxFrequency = 0;
for (const number in frequencyMap) {
const frequency = frequencyMap[number];
if (frequency > maxFrequency) {
maxFrequency = frequency;
modes = [parseInt(number)];
} else if (frequency === maxFrequency) {
modes.push(parseInt(number));
}
}
return modes;
}
const input = [5, 4, 5, 6, 6, 6, 7, 5];
const result = findModes(input);
console.log(result);
Output
[ 5, 6 ]
Time Complexity : O(n)
Space Complexity : O(n)
Finding Mode in an Array using an object
To find mode in an array we will create an object to find mode in an array using JavaScript. Then we will traverse through the array and count the frequency of each element. Now we will find which element has the maximum frequency. We will return the element having maximum frequency. If more than one element exists we will return all the elements.
Example: Implementation of Finding Mode in an Array in JavaScript using an object
function mode(input) {
// Object to store the frequency of each element
let mode = {};
// Variable to store the frequency of the current mode
let maxCount = 0;
// Array to store the modes
let modes = [];
// Iterate through each element of the input array
input.forEach(function (e) {
if (mode[e] == null) {
mode[e] = 1;
} else {
mode[e]++;
}
if (mode[e] > maxCount) {
// Update the current mode and its frequency
modes = [e];
maxCount = mode[e];
} else if (mode[e] === maxCount) {
modes.push(e);
}
});
return modes;
}
let input = [1, 2, 3, 3, 3, 2, 2];
console.log(mode(input));
Output
[ 3, 2 ]
Time Complexity : O(n)
Space Complexity : O(n)
Finding Mode in an Array using Sorting
This approach involves sorting the array, and then iterating through it to count each element’s occurrences. We update the mode whenever we encounter a new maximum count. Finally, we return the mode element.
Example: Implementation of Finding Mode in an Array in JavaScript using sorting.
function Mode(arr) {
// Sort the array in ascending order
arr.sort((a, b) => a - b);
let modes = [];
let maxCount = 0;
let currentCount = 1;
let i = 0;
while (i < arr.length) {
// Count the occurrences of the current element
while (i < arr.length - 1 &&
arr[i] === arr[i + 1]) {
currentCount++;
i++;
}
// Update the modes array if needed
if (currentCount === maxCount) {
modes.push(arr[i]);
} else if (currentCount > maxCount) {
maxCount = currentCount;
modes = [arr[i]];
}
// Reset currentCount for the next element
currentCount = 1;
i++;
}
return modes;
}
const input = [1, 2, 3, 3, 3, 2, 2];
const modes = Mode(input);
console.log(modes);
Output
[ 2, 3 ]
Time Complexity : O(nlogn)
Space Complexity : O(logn)
Contact Us