Given an array, find the most frequent element in it. If there are multiple elements that appear a 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 : 20A simple solution is to run two loops. The outer loop picks all elements one by one. The inner loop finds the frequency of the picked element and compares it with the maximum so far. The time complexity of this solution is O(n2)
A better solution is to do the 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 the 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));
}
}
|
Javascript
<script>
function mostFrequent(arr, n)
{
var hash = new Map();
for (var i = 0; i < n; i++)
{
if(hash.has(arr[i]))
hash.set(arr[i], hash.get(arr[i])+1)
else
hash.set(arr[i], 1)
}
var max_count = 0, res = -1;
hash.forEach((value,key) => {
if (max_count < value) {
res = key;
max_count = value;
}
});
return res;
}
var arr = [1, 5, 2, 1, 3, 2, 1];
var n = arr.length;
document.write( mostFrequent(arr, n));
</script>
|
Time Complexity : O(n)
Auxiliary Space : O(n)
An efficient solution of this problem can be to solve this problem by Moore’s voting Algorithm.
NOTE: THE ABOVE VOTING ALGORITHM ONLY WORKS WHEN THE MAXIMUM OCCURRING ELEMENT IS MORE THAN (SIZEOFARRAY/2) TIMES;
In this method, we will find the maximum occurred integer by counting the votes a number has.
C++
#include <iostream>
using namespace std;
int maxFreq(int *arr, int n) {
int res = 0;
int count = 1;
for(int i = 1; i < n; i++) {
if(arr[i] == arr[res]) {
count++;
} else {
count--;
}
if(count == 0) {
res = i;
count = 1;
}
}
return arr[res];
}
int main()
{
int arr[] = {40,50,30,40,50,30,30};
int n = sizeof(arr) / sizeof(arr[0]);
int freq = maxFreq(arr , n);
int count = 0;
for(int i = 0; i < n; i++) {
if(arr[i] == freq) {
count++;
}
}
cout <<"Element " << maxFreq(arr , n) << " occurs " << count << " times" << endl;;
return 0;
}
|
Java
import java.io.*;
class GFG
{
static int maxFreq(int []arr, int n)
{
int res = 0;
int count = 1;
for(int i = 1; i < n; i++) {
if(arr[i] == arr[res]) {
count++;
} else {
count--;
}
if(count == 0) {
res = i;
count = 1;
}
}
return arr[res];
}
public static void main (String[] args) {
int arr[] = {40,50,30,40,50,30,30};
int n = arr.length;
int freq = maxFreq(arr , n);
int count = 0;
for(int i = 0; i < n; i++) {
if(arr[i] == freq) {
count++;
}
}
System.out.println("Element " +maxFreq(arr , n) +" occurs " +count +" times" );
}
}
|
Python3
def maxFreq(arr, n):
res = 0
count = 1
for i in range(1, n):
if (arr[i] == arr[res]):
count += 1
else:
count -= 1
if (count == 0):
res = i
count = 1
return arr[res]
arr = [ 40, 50, 30, 40, 50, 30, 30 ]
n = len(arr)
freq = maxFreq(arr, n)
count = 0
for i in range (n):
if(arr[i] == freq):
count += 1
print("Element ", maxFreq(arr , n),
" occurs ", count, " times")
|
C#
using System;
class GFG
{
static int maxFreq(int []arr, int n)
{
int res = 0;
int count = 1;
for(int i = 1; i < n; i++) {
if(arr[i] == arr[res]) {
count++;
} else {
count--;
}
if(count == 0) {
res = i;
count = 1;
}
}
return arr[res];
}
public static void Main (String[] args) {
int []arr = {40,50,30,40,50,30,30};
int n = arr.Length;
int freq = maxFreq(arr , n);
int count = 0;
for(int i = 0; i < n; i++) {
if(arr[i] == freq) {
count++;
}
}
Console.Write("Element " +maxFreq(arr , n) +" occurs " +count +" times" );
}
}
|
Javascript
<script>
function maxFreq(arr, n) {
var res = 0;
var count = 1;
for (var i = 1; i < n; i++) {
if (arr[i] === arr[res]) {
count++;
} else {
count--;
}
if (count === 0) {
res = i;
count = 1;
}
}
return arr[res];
}
var arr = [40, 50, 30, 40, 50, 30, 30];
var n = arr.length;
var freq = maxFreq(arr, n);
var count = 0;
for (var i = 0; i < n; i++) {
if (arr[i] === freq) {
count++;
}
}
document.write(
"Element " + maxFreq(arr, n) + " occurs " +
count + " times" + "<br>"
);
</script>
|
OutputElement 30 occurs 3 times
Time Complexity : O(n)
Space Complexity : O(1)
.png)
.png)