Thursday, October 16, 2025
HomeData Modelling & AIMode of frequencies of given array elements

Mode of frequencies of given array elements

Given an array arr[], the task is to find the mode of frequencies of elements of the given array.

Examples:

Input: arr[] = {6, 10, 3, 10, 8, 3, 6, 4}, N = 8
Output: 2
Explanation:
Here (3, 10 and 6) have frequency 2, while (4 and 8) have frequency 1.
Three numbers have frequency 2, while 2 numbers have frequency 1.
Thus, the mode of the frequencies is 2.

Input: arr[] = {5, 9, 2, 9, 7, 2, 5, 3, 1}, N = 9
Output:1

Approach: The idea is to find the frequency of the frequencies of all array elements. Finally, compute the mode of the frequencies.

Below is the implementation of the above approach:

C++




// C++ program of the
// above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the mode of the
// frequency of the array
int countFreq(int arr[], int n)
{
 
    // Stores the frequencies
    // of array elements
    unordered_map<int, int> mp1;
 
    // Traverse through array
    // elements and
    // count frequencies
    for (int i = 0; i < n; ++i) {
        mp1[arr[i]]++;
    }
 
    // Stores the frequencies's of
    // frequencies of array elements
    unordered_map<int, int> mp2;
 
    for (auto it : mp1) {
        mp2[it.second]++;
    }
 
    // Stores the minimum value
    int M = INT_MIN;
 
    // Find the Mode in 2nd map
    for (auto it : mp2) {
        M = max(M, it.second);
    }
 
    // search for this Mode
    for (auto it : mp2) {
        // When mode is find then return
        // to main function.
        if (M == it.second) {
            return it.first;
        }
    }
 
    // If mode is not found
    return 0;
}
 
// Driver Code
int main()
{
    int arr[] = { 6, 10, 3, 10, 8, 3, 6, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << countFreq(arr, n);
    return 0;
}


Java




// Java program of the
// above approach
import java.util.*;
 
class GFG{
 
// Function to find the mode of the
// frequency of the array
static int countFreq(int arr[], int n)
{
     
    // Stores the frequencies
    // of array elements
    HashMap<Integer,
            Integer> mp1 = new HashMap<Integer,
                                       Integer>();
 
    // Traverse through array
    // elements and
    // count frequencies
    for(int i = 0; i < n; ++i)
    {
        if (mp1.containsKey(arr[i]))
        {
            mp1.put(arr[i], mp1.get(arr[i]) + 1);
        }
        else
        {
            mp1.put(arr[i], 1);
        }
    }
 
    // Stores the frequencies's of
    // frequencies of array elements
    HashMap<Integer,
            Integer> mp2 = new HashMap<Integer,
                                       Integer>();
 
    for(Map.Entry<Integer,
                  Integer> it : mp1.entrySet())
    {
        if (mp2.containsKey(it.getValue()))
        {
            mp2.put(it.getValue(),
            mp2.get(it.getValue()) + 1);
        }
        else
        {
            mp2.put(it.getValue(), 1);
        }
    }
 
    // Stores the minimum value
    int M = Integer.MIN_VALUE;
 
    // Find the Mode in 2nd map
    for(Map.Entry<Integer,
                  Integer> it : mp2.entrySet())
    {
        M = Math.max(M, it.getValue());
    }
 
    // Search for this Mode
    for(Map.Entry<Integer,
                  Integer> it : mp2.entrySet())
    {
         
        // When mode is find then return
        // to main function.
        if (M == it.getValue())
        {
            return it.getKey();
        }
    }
 
    // If mode is not found
    return 0;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 6, 10, 3, 10, 8, 3, 6, 4 };
    int n = arr.length;
     
    System.out.print(countFreq(arr, n));
}
}
 
// This code is contributed by Amit Katiyar


Python3




# Python3 program of the
# above approach
from collections import defaultdict
import sys
 
# Function to find the mode of the
# frequency of the array
def countFreq(arr, n):
 
  # Stores the frequencies
  # of array elements
  mp1 = defaultdict (int)
 
  # Traverse through array
  # elements and
  # count frequencies
  for i in range (n):
    mp1[arr[i]] += 1
 
    # Stores the frequencies's of
    # frequencies of array elements
    mp2 = defaultdict (int)
 
    for it in mp1:
      mp2[mp1[it]] += 1
 
      # Stores the minimum value
      M = -sys.maxsize - 1
 
      # Find the Mode in 2nd map
      for it in mp2:
        M = max(M, mp2[it])
 
        # search for this Mode
        for it in mp2:
           
          # When mode is find then return
          # to main function.
           
          if (M == mp2[it]):
            return it
 
          # If mode is not found
          return 0
 
# Driver Code
if __name__ == "__main__":
 
  arr = [6, 10, 3, 10,
         8, 3, 6, 4]
  n = len(arr)
  print (countFreq(arr, n))
     
# This code is contributed by Chitranayal


C#




// C# program of the
// above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to find the mode of the
// frequency of the array
static int countFreq(int []arr, int n)
{
     
    // Stores the frequencies
    // of array elements
    Dictionary<int,
               int> mp1 = new Dictionary<int,
                                         int>();
 
    // Traverse through array
    // elements and
    // count frequencies
    for(int i = 0; i < n; ++i)
    {
        if (mp1.ContainsKey(arr[i]))
        {
            mp1[arr[i]] = mp1[arr[i]] + 1;
        }
        else
        {
            mp1.Add(arr[i], 1);
        }
    }
 
    // Stores the frequencies's of
    // frequencies of array elements
    Dictionary<int,
               int> mp2 = new Dictionary<int,
                                         int>();
 
    foreach(KeyValuePair<int, int> it in mp1)
    {
        if (mp2.ContainsKey(it.Value))
        {
            mp2[it.Value] =
            mp2[it.Value] + 1;
        }
        else
        {
            mp2.Add(it.Value, 1);
        }
    }
 
    // Stores the minimum value
    int M = int.MinValue;
 
    // Find the Mode in 2nd map
    foreach(KeyValuePair<int, int> it in mp2)
    {
        M = Math.Max(M, it.Value);
    }
 
    // Search for this Mode
    foreach(KeyValuePair<int, int> it in mp2)
    {
         
        // When mode is find then return
        // to main function.
        if (M == it.Value)
        {
            return it.Key;
        }
    }
 
    // If mode is not found
    return 0;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 6, 10, 3, 10, 8, 3, 6, 4 };
    int n = arr.Length;
     
    Console.Write(countFreq(arr, n));
}
}
 
// This code is contributed by Amit Katiyar


Javascript




<script>
// Javascript program of the
// above approach
 
// Function to find the mode of the
// frequency of the array
function countFreq(arr,n)
{
 
    // Stores the frequencies
    // of array elements
    let mp1 = new Map();
   
    // Traverse through array
    // elements and
    // count frequencies
    for(let i = 0; i < n; ++i)
    {
        if (mp1.has(arr[i]))
        {
            mp1.set(arr[i], mp1.get(arr[i]) + 1);
        }
        else
        {
            mp1.set(arr[i], 1);
        }
    }
   
    // Stores the frequencies's of
    // frequencies of array elements
    let mp2 = new Map();
   
    for(let [key, value] of mp1.entries())
    {
        if (mp2.has(value))
        {
            mp2.set(value,
            mp2.get(value) + 1);
        }
        else
        {
            mp2.set(value, 1);
        }
    }
   
    // Stores the minimum value
    let M = Number.MIN_VALUE;
   
    // Find the Mode in 2nd map
    for(let [key, value] of mp2.entries())
    {
        M = Math.max(M, value);
    }
   
    // Search for this Mode
    for(let [key, value] of mp2.entries())
    {
           
        // When mode is find then return
        // to main function.
        if (M == value)
        {
            return key;
        }
    }
   
    // If mode is not found
    return 0;
}
 
// Driver Code
let arr = [ 6, 10, 3, 10, 8, 3, 6, 4];
let n = arr.length;
document.write(countFreq(arr, n));   
 
// This code is contributed by avanitrachhadiya2155
</script>


Output: 

2

Time Complexity: O(N) 
Auxiliary Space: O(N)

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Dominic
32361 POSTS0 COMMENTS
Milvus
88 POSTS0 COMMENTS
Nango Kala
6728 POSTS0 COMMENTS
Nicole Veronica
11892 POSTS0 COMMENTS
Nokonwaba Nkukhwana
11954 POSTS0 COMMENTS
Shaida Kate Naidoo
6852 POSTS0 COMMENTS
Ted Musemwa
7113 POSTS0 COMMENTS
Thapelo Manthata
6805 POSTS0 COMMENTS
Umr Jansen
6801 POSTS0 COMMENTS