Mode is the value which occurs most frequently in a set of observations. For example, {6, 3, 9, 6, 6, 5, 9, 3} the Mode is 6, as it occurs most often.
Fact about Mode :
- Sometimes there can be more than one mode.Having two modes is called bimodal.Having more than two modes is called multimodal.
- There is an empirical relationship between Mean, Median, and Mode.
Mean – Mode = 3 [ Mean – Median ]
Python3
import numpy as np
from scipy import stats
l1 = [ 12 , 15 , 12 , 78 , 54 , 56 , 45 , 45 , 18 , 19 , 12 , 35 , 67 , 48 , 9 , 2 , 45 , 68 ]
print (f "List: {l1}" )
print (f "Mean: {np.mean(l1)}" )
print (f "Median: {np.median(l1)}" )
print (f "Mode: {stats.mode(l1)[0]}" )
lhs = np.mean(l1) - stats.mode(l1)[ 0 ]
rhs = 3 * (np.mean(l1) - np.median(l1))
print (f "LHS == RHS: {lhs == rhs}" )
|
- Mode can be useful for qualitative data.
- Mode can be located graphically.
- Mode can be computed in an open-end frequency table.
- Mode is not affected by extremely large or small values.
Formula for Mode of grouped data :

How to find Mode?
Naive solution:
Given an n sized unsorted array, find median and mode using counting sort technique. This can be useful when array elements are in limited range.
Examples:
Input : array a[] = {1, 1, 1, 2, 7, 1}
Output : Mode = 1
Input : array a[] = {9, 9, 9, 9, 9}
Output : Mode = 9
- Auxiliary(count) array before summing its previous counts, c[]:
Index: 0 1 2 3 4 5 6 7 8 9 10
count: 0 4 1 0 0 0 0 1 0 0 0
- Mode = index with maximum value of count.
Mode = 1(for above example)
Approach :
Assuming size of input array is n:
Step #1: Take the count array before summing its previous counts into next index.
Step #2: The index with maximum value stored in it is the mode of given data.
Step #3: In case there are more than one indexes with maximum value in it, all are results for mode so we can take any.
Step #4: Store the value at that index in a separate variable called mode.
Below is the implementation:
C++
#include <bits/stdc++.h>
using namespace std;
void printMode( int a[], int n)
{
int b[n];
int max = *max_element(a, a + n);
int t = max + 1;
int count[t];
for ( int i = 0; i < t; i++)
count[i] = 0;
for ( int i = 0; i < n; i++)
count[a[i]]++;
int mode = 0;
int k = count[0];
for ( int i = 1; i < t; i++) {
if (count[i] > k) {
k = count[i];
mode = i;
}
}
cout << "mode = " << mode;
}
int main()
{
int a[] = { 1, 4, 1, 2, 7, 1, 2, 5, 3, 6 };
int n = sizeof (a) / sizeof (a[0]);
printMode(a, n);
return 0;
}
|
Java
import java.util.Arrays;
class GFG
{
static void printMode( int [] a, int n)
{
int max = Arrays.stream(a).max().getAsInt();
int t = max + 1 ;
int [] count = new int [t];
for ( int i = 0 ; i < t; i++)
{
count[i] = 0 ;
}
for ( int i = 0 ; i < n; i++)
{
count[a[i]]++;
}
int mode = 0 ;
int k = count[ 0 ];
for ( int i = 1 ; i < t; i++)
{
if (count[i] > k)
{
k = count[i];
mode = i;
}
}
System.out.println( "mode = " + mode);
}
public static void main(String[] args)
{
int [] a = { 1 , 4 , 1 , 2 , 7 , 1 , 2 , 5 , 3 , 6 };
int n = a.length;
printMode(a, n);
}
}
|
Python3
def printMode(a, n) :
max_element = max (a)
t = max_element + 1
count = [ 0 ] * t
for i in range (t) :
count[i] = 0
for i in range (n) :
count[a[i]] + = 1
mode = 0
k = count[ 0 ]
for i in range ( 1 , t) :
if (count[i] > k) :
k = count[i]
mode = i
print ( "mode = " , mode)
if __name__ = = "__main__" :
a = [ 1 , 4 , 1 , 2 , 7 ,
1 , 2 , 5 , 3 , 6 ]
n = len (a)
printMode(a, n)
|
C#
using System;
using System.Linq;
public class GFG{
static void printMode( int []a, int n)
{
int max =a.Max();
int t = max + 1;
int []count = new int [t];
for ( int i = 0; i < t; i++)
count[i] = 0;
for ( int i = 0; i < n; i++)
count[a[i]]++;
int mode = 0;
int k = count[0];
for ( int i = 1; i < t; i++) {
if (count[i] > k) {
k = count[i];
mode = i;
}
}
Console.WriteLine( "mode = " + mode);
}
static public void Main (){
int []a = { 1, 4, 1, 2, 7, 1, 2, 5, 3, 6 };
int n =a.Length;
printMode(a, n);
}
}
|
Javascript
<script>
function printMode(a, n)
{
let max = Number.MIN_VALUE;
for (let i = 0; i < a.length; i++)
{
max = Math.max(max, a[i]);
}
let t = max + 1;
let count = new Array(t);
for (let i = 0; i < t; i++)
count[i] = 0;
for (let i = 0; i < n; i++)
count[a[i]]++;
let mode = 0;
let k = count[0];
for (let i = 1; i < t; i++) {
if (count[i] > k) {
k = count[i];
mode = i;
}
}
document.write( "mode = " + mode);
}
let a = [ 1, 4, 1, 2, 7, 1, 2, 5, 3, 6 ];
let n =a.length;
printMode(a, n);
</script>
|
Output:
mode = 1
Time Complexity = O(N + P), where N is the size of input array and P is size of the count array or maximum value in input array.
Auxiliary Space = O(P), where the value of P is the size of auxiliary array.
The above solutions works good when array element values are small. Please refer below post for efficient solutions.
Most frequent element in an array
Basic Program related to Mode :
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 geeks!