Mode

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 :

  1. Sometimes there can be more than one mode.Having two modes is called bimodal.Having more than two modes is called multimodal.
  2. There is an empirical relationship between Mean, Median, and Mode.
    Mean – Mode = 3 [ Mean – Median ]



  3. Mode can be useful for qualitative data.
  4. Mode can be located graphically.
  5. Mode can be computed in an open-end frequency table.
  6. 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program for Mode using 
// Counting Sort technique
#include <bits/stdc++.h>
using namespace std;
  
// Function that sort input array a[] and
// calculate mode and median using counting
// sort.
void printMode(int a[], int n)
{
    // The output array b[] will
    // have sorted array
    int b[n];
  
    // variable to store max of
    // input array which will
    // to have size of count array
    int max = *max_element(a, a + n);
  
    // auxiliary(count) array to
    // store count. Initialize
    // count array as 0. Size
    // of count array will be
    // equal to (max + 1).
    int t = max + 1;
    int count[t];
    for (int i = 0; i < t; i++)
        count[i] = 0;
  
    // Store count of each element
    // of input array
    for (int i = 0; i < n; i++)
        count[a[i]]++;
  
    // mode is the index with maximum count
    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;
}
  
// Driver Code
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;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// Java Program for Mode using  


// Counting Sort technique 


import java.util.Arrays; 


  


class GFG 


{ 


  


    // Function that sort input array a[] and 


    // calculate mode and median using counting 


    // sort. 


    static void printMode(int[] a, int n) 


    { 


        // The output array b[] will 


        // have sorted array 


        //int []b = new int[n]; 


  


        // variable to store max of 


        // input array which will 


        // to have size of count array 


        int max = Arrays.stream(a).max().getAsInt(); 


  


        // auxiliary(count) array to 


        // store count. Initialize 


        // count array as 0. Size 


        // of count array will be 


        // equal to (max + 1). 


        int t = max + 1; 


        int[] count = new int[t]; 


        for (int i = 0; i < t; i++)  


        { 


            count[i] = 0; 


        } 


  


        // Store count of each element 


        // of input array 


        for (int i = 0; i < n; i++) 


        { 


            count[a[i]]++; 


        } 


  


        // mode is the index with maximum count 


        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); 


    } 


  


    // Driver Code 


    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); 


    } 


} 


  


// This code is contributed by Rajput-Ji 



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python3 Program for Mode using  


# Counting Sort technique  


  


# Function that sort input array a[] and  


# calculate mode and median using counting  


# sort.  


def printMode(a, n) : 


  


    # variable to store max of  


    # input array which will  


    # to have size of count array  


    max_element = max(a)  


  


    # auxiliary(count) array to store count.  


    # Initialize count array as 0. Size  


    # of count array will be equal to (max + 1).  


    t = max_element + 1


    count = [0] * t 


      


    for i in range(t) : 


        count[i] = 0


  


    # Store count of each element  


    # of input array  


    for i in range(n) : 


        count[a[i]] += 1


  


    # mode is the index with maximum count  


    mode = 0


    k = count[0] 


    for i in range(1, t) :  


        if (count[i] > k) :  


            k = count[i] 


            mode = i  


          


    print("mode = ", mode)  


  


# Driver Code  


if __name__ == "__main__" : 


      


    a = [ 1, 4, 1, 2, 7,  


          1, 2, 5, 3, 6 ] 


    n = len(a) 


    printMode(a, n) 


  


# This code is contributed by Ryuga  



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// C# Program for Mode using  


// Counting Sort technique 


using System; 


using System.Linq; 


public class GFG{ 


     


  


  


// Function that sort input array a[] and 


// calculate mode and median using counting 


// sort. 


 static void printMode(int []a, int n) 


{ 


    // The output array b[] will 


    // have sorted array 


    //int []b = new int[n]; 


  


    // variable to store max of 


    // input array which will 


    // to have size of count array 


    int max =a.Max(); 


  


    // auxiliary(count) array to 


    // store count. Initialize 


    // count array as 0. Size 


    // of count array will be 


    // equal to (max + 1). 


    int t = max + 1; 


    int []count = new int[t]; 


    for (int i = 0; i < t; i++) 


        count[i] = 0; 


  


    // Store count of each element 


    // of input array 


    for (int i = 0; i < n; i++) 


        count[a[i]]++; 


  


    // mode is the index with maximum count 


    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); 


} 


  


// Driver Code 


  


    static public void Main (){ 


    int []a = { 1, 4, 1, 2, 7, 1, 2, 5, 3, 6 }; 


    int n =a.Length; 


    printMode(a, n); 


    } 


} 


// This code is contributed by inder_verma 



















                        chevron_right







                        filter_none










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 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 :




          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts: