Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Mode of frequencies of given array elements

  • Difficulty Level : Medium
  • Last Updated : 27 Aug, 2021

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

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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)



My Personal Notes
arrow_drop_up
Previous
Maximize cost to empty an array by removing contiguous subarrays of equal elements
Next

Minimize replacement of characters to its nearest alphabet to make a string palindromic
Recommended Articles
Page :
Find frequencies of elements of an array present in another array
03, Nov 21
Range Queries for Frequencies of array elements
20, Feb 17
Count frequencies of all elements in array in Python using collections module
28, Oct 17
Elements of first array that have more frequencies
05, Aug 18
Counting frequencies of array elements
03, Sep 18
Find array elements with frequencies in range [l , r]
10, Nov 18
Array elements with prime frequencies
12, Nov 18
Sum of elements in an array with frequencies greater than or equal to that element
11, Dec 18
Find element in array with frequency equal to sum of frequencies of other elements
08, Apr 20
Count frequencies of all elements in array in O(1) extra space and O(n) time
23, Jun 15
Find the frequencies of all duplicates elements in the array
25, Mar 20
Print all array elements having frequencies equal to powers of K in ascending order
10, Mar 21
Queries to count frequencies of a given character in a given range of indices
25, Oct 20
Count of subarrays of size K with elements having even frequencies
14, Jun 20
Calculate Median from given values of Mean and Mode
09, Apr 21
Character whose frequency is equal to the sum of frequencies of other characters of the given string
11, Mar 19
Construct a sequence from given frequencies of N consecutive integers with unit adjacent difference
13, Jul 20
Generate a Number in Decreasing order of Frequencies of characters of a given String
28, Jul 20
Remove characters from given string whose frequencies are a Prime Number
02, Dec 20
Nearest power of 2 of frequencies of each digit of a given number
03, Mar 21
Difference between highest and least frequencies in an array
29, Sep 17
Smallest number to be added in first Array modulo M to make frequencies of both Arrays equal
03, Jul 20
Sort array of strings after sorting each string after removing characters whose frequencies are not a powers of 2
14, Apr 21
Mode
13, Dec 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
vivekpatel7202
@vivekpatel7202
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!