Given an array, find the most frequent element in it. If there are multiple elements that appear maximum number of times, print any one of them.
Examples:
Input : arr[] = {1, 3, 2, 1, 4, 1}
Output : 1
1 appears three times in array which
is maximum frequency.
Input : arr[] = {10, 20, 10, 20, 30, 20, 20}
Output : 20
A simple solution is to run two loops. The outer loop picks all elements one by one. The inner loop finds frequency of the picked element and compares with the maximum so far. Time complexity of this solution is O(n2)
A better solution is to do sorting. We first sort the array, then linearly traverse the array.
C++
#include <bits/stdc++.h>
using namespace std;
int mostFrequent( int arr[], int n)
{
sort(arr, arr + n);
int max_count = 1, res = arr[0], curr_count = 1;
for ( int i = 1; i < n; i++) {
if (arr[i] == arr[i - 1])
curr_count++;
else {
if (curr_count > max_count) {
max_count = curr_count;
res = arr[i - 1];
}
curr_count = 1;
}
}
if (curr_count > max_count)
{
max_count = curr_count;
res = arr[n - 1];
}
return res;
}
int main()
{
int arr[] = { 1, 5, 2, 1, 3, 2, 1 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << mostFrequent(arr, n);
return 0;
}
|
Java
import java.util.*;
class GFG {
static int mostFrequent( int arr[], int n)
{
Arrays.sort(arr);
int max_count = 1 , res = arr[ 0 ];
int curr_count = 1 ;
for ( int i = 1 ; i < n; i++)
{
if (arr[i] == arr[i - 1 ])
curr_count++;
else
{
if (curr_count > max_count)
{
max_count = curr_count;
res = arr[i - 1 ];
}
curr_count = 1 ;
}
}
if (curr_count > max_count)
{
max_count = curr_count;
res = arr[n - 1 ];
}
return res;
}
public static void main (String[] args) {
int arr[] = { 1 , 5 , 2 , 1 , 3 , 2 , 1 };
int n = arr.length;
System.out.println(mostFrequent(arr,n));
}
}
|
Python3
def mostFrequent(arr, n):
arr.sort()
max_count = 1 ; res = arr[ 0 ]; curr_count = 1
for i in range ( 1 , n):
if (arr[i] = = arr[i - 1 ]):
curr_count + = 1
else :
if (curr_count > max_count):
max_count = curr_count
res = arr[i - 1 ]
curr_count = 1
if (curr_count > max_count):
max_count = curr_count
res = arr[n - 1 ]
return res
arr = [ 1 , 5 , 2 , 1 , 3 , 2 , 1 ]
n = len (arr)
print (mostFrequent(arr, n))
|
C#
using System;
class GFG {
static int mostFrequent( int []arr, int n)
{
Array.Sort(arr);
int max_count = 1, res = arr[0];
int curr_count = 1;
for ( int i = 1; i < n; i++)
{
if (arr[i] == arr[i - 1])
curr_count++;
else
{
if (curr_count > max_count)
{
max_count = curr_count;
res = arr[i - 1];
}
curr_count = 1;
}
}
if (curr_count > max_count)
{
max_count = curr_count;
res = arr[n - 1];
}
return res;
}
public static void Main ()
{
int []arr = {1, 5, 2, 1, 3, 2, 1};
int n = arr.Length;
Console.WriteLine(mostFrequent(arr,n));
}
}
|
PHP
<?php
function mostFrequent( $arr , $n )
{
sort( $arr );
sort( $arr , $n );
$max_count = 1;
$res = $arr [0];
$curr_count = 1;
for ( $i = 1; $i < $n ; $i ++)
{
if ( $arr [ $i ] == $arr [ $i - 1])
$curr_count ++;
else
{
if ( $curr_count > $max_count )
{
$max_count = $curr_count ;
$res = $arr [ $i - 1];
}
$curr_count = 1;
}
}
if ( $curr_count > $max_count )
{
$max_count = $curr_count ;
$res = $arr [ $n - 1];
}
return $res ;
}
{
$arr = array (1, 5, 2, 1, 3, 2, 1);
$n = sizeof( $arr ) / sizeof( $arr [0]);
echo mostFrequent( $arr , $n );
return 0;
}
?>
|
Javascript
<script>
function mostFrequent(arr, n)
{
arr.sort();
let max_count = 1, res = arr[0];
let curr_count = 1;
for (let i = 1; i < n; i++)
{
if (arr[i] == arr[i - 1])
curr_count++;
else
{
if (curr_count > max_count)
{
max_count = curr_count;
res = arr[i - 1];
}
curr_count = 1;
}
}
if (curr_count > max_count)
{
max_count = curr_count;
res = arr[n - 1];
}
return res;
}
let arr = [1, 5, 2, 1, 3, 2, 1];
let n = arr.length;
document.write(mostFrequent(arr,n));
</script>
|
Time Complexity : O(n Log n)
Auxiliary Space : O(1)
An efficient solution is to use hashing. We create a hash table and store elements and their frequency counts as key value pairs. Finally we traverse the hash table and print the key with maximum value.
C++
#include <bits/stdc++.h>
using namespace std;
int mostFrequent( int arr[], int n)
{
unordered_map< int , int > hash;
for ( int i = 0; i < n; i++)
hash[arr[i]]++;
int max_count = 0, res = -1;
for ( auto i : hash) {
if (max_count < i.second) {
res = i.first;
max_count = i.second;
}
}
return res;
}
int main()
{
int arr[] = { 1, 5, 2, 1, 3, 2, 1 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << mostFrequent(arr, n);
return 0;
}
|
Java
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
class GFG {
static int mostFrequent( int arr[], int n)
{
Map<Integer, Integer> hp =
new HashMap<Integer, Integer>();
for ( int i = 0 ; i < n; i++)
{
int key = arr[i];
if (hp.containsKey(key))
{
int freq = hp.get(key);
freq++;
hp.put(key, freq);
}
else
{
hp.put(key, 1 );
}
}
int max_count = 0 , res = - 1 ;
for (Entry<Integer, Integer> val : hp.entrySet())
{
if (max_count < val.getValue())
{
res = val.getKey();
max_count = val.getValue();
}
}
return res;
}
public static void main (String[] args) {
int arr[] = { 1 , 5 , 2 , 1 , 3 , 2 , 1 };
int n = arr.length;
System.out.println(mostFrequent(arr, n));
}
}
|
Python3
import math as mt
def mostFrequent(arr, n):
Hash = dict ()
for i in range (n):
if arr[i] in Hash .keys():
Hash [arr[i]] + = 1
else :
Hash [arr[i]] = 1
max_count = 0
res = - 1
for i in Hash :
if (max_count < Hash [i]):
res = i
max_count = Hash [i]
return res
arr = [ 1 , 5 , 2 , 1 , 3 , 2 , 1 ]
n = len (arr)
print (mostFrequent(arr, n))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int mostFrequent( int []arr,
int n)
{
Dictionary< int , int > hp =
new Dictionary< int , int >();
for ( int i = 0; i < n; i++)
{
int key = arr[i];
if (hp.ContainsKey(key))
{
int freq = hp[key];
freq++;
hp[key] = freq;
}
else
hp.Add(key, 1);
}
int min_count = 0, res = -1;
foreach (KeyValuePair< int ,
int > pair in hp)
{
if (min_count < pair.Value)
{
res = pair.Key;
min_count = pair.Value;
}
}
return res;
}
static void Main ()
{
int []arr = new int []{1, 5, 2,
1, 3, 2, 1};
int n = arr.Length;
Console.Write(mostFrequent(arr, n));
}
}
|
Time Complexity : O(n)
Auxiliary Space : O(n)
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.