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

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

Javascript

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

Javascript

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.

Javascript

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)