Related Articles

# Median and Mode using Counting Sort

• Difficulty Level : Easy
• Last Updated : 18 Aug, 2020

Given an n sized unsorted array, find median and mode using counting sort technique. Thia can be useful when array elements are in limited range.

Examples:

```Input : array a[] = {1, 1, 1, 2, 7, 1}
Output : Mode = 1
Median = 1
Note : Median is average of middle two numbers (1 and 1)

Input : array a[] = {9, 9, 9, 9, 9}
Output : Mode = 9
Median = 9
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Prerequisites: Count Sort, Median of Array, Mode (Most frequent element in array)

Input = [1, 4, 1, 2, 7, 1, 2, 5, 3, 6]

1. Auxiliary(count) array before summing its previous counts, c[]:
Index: 0 1 2 3 4 5 6 7 8 9 10
count: 0 3 2 1 1 1 1 1 0 0 0

2. Mode = index with maximum value of count.
Mode = 1(for above example)

3. count array is modified similarly as it is done while performing count sort.
Index: 0 1 2 3 4 5 6 7 8 9 10
count: 0 3 5 6 7 8 9 10 10 10 10

4. output array is calculated normally as in count sort, b[]:
output array b[] = {1, 1, 1, 2, 2, 3, 4, 5, 6, 7}

5. If size of array b[] is odd, Median = b[n/2]
Else Median = (b[(n-1)/2] + b[n/2])/2

6. For above example size of b[] is even hence, Median = (b[4] + b[5])/2.
Median = (2 + 3)/2 = 2.5

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Basic Approach to be followed :
Assuming size of input array is n:
Step1: Take the count array before summing its previous counts into next index.
Step2: The index with maximum value stored in it is the mode of given data.
Step3: In case there are more than one indexes with maximum value in it, all are results for mode so we can take any.
Step4: Store the value at that index in a separate variable called mode.
Step5: Continue with the normal processing of the count sort.
Step6: In the resultant(sorted) array, if n is odd then median = middle-most element of the
sorted array, And if n is even the median = average of two middle-most elements of the sorted array.
Step7: Store the result in a separate variable called median.

Following is the implementation of problem discussed above:

## C++

 `// C++ Program for Mode and``// Median using Counting``// Sort technique``#include ``using` `namespace` `std;`` ` `// function that sort input array a[] and ``// calculate mode and median using counting``// sort.``void` `printModeMedian(``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;``        ``}``    ``}    `` ` `    ``// Update count[] array with sum``    ``for` `(``int` `i = 1; i < t; i++)``        ``count[i] = count[i] + count[i-1];`` ` `    ``// Sorted output array b[]``    ``// to calculate median``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``b[count[a[i]]-1] = a[i];``        ``count[a[i]]--;``    ``}``     ` `    ``// Median according to odd and even ``    ``// array size respectively.``    ``float` `median;``    ``if` `(n % 2 != 0)``        ``median = b[n/2];``    ``else``        ``median = (b[(n-1)/2] + ``                  ``b[(n/2)])/2.0;``     ` `    ``// Output the result ``    ``cout << ``"median = "` `<< median << endl;``    ``cout << ``"mode = "` `<< mode;``}`` ` `// Driver program``int` `main()``{``    ``int` `a[] = { 1, 4, 1, 2, 7, 1, 2,  5, 3, 6 };``    ``int` `n = ``sizeof``(a)/``sizeof``(a[0]);``    ``printModeMedian(a, n);``    ``return` `0;``}`

## Java

 `import` `java.util.Arrays;`` ` `// Java Program for Mode and ``// Median using Counting ``// Sort technique ``class` `GFG ``{``// function that sort input array a[] and ``// calculate mode and median using counting ``// sort. `` ` `    ``static` `void` `printModeMedian(``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;``            ``}``        ``}`` ` `        ``// Update count[] array with sum ``        ``for` `(``int` `i = ``1``; i < t; i++)``        ``{``            ``count[i] = count[i] + count[i - ``1``];``        ``}`` ` `        ``// Sorted output array b[] ``        ``// to calculate median ``        ``for` `(``int` `i = ``0``; i < n; i++) ``        ``{``            ``b[count[a[i]] - ``1``] = a[i];``            ``count[a[i]]--;``        ``}`` ` `        ``// Median according to odd and even ``        ``// array size respectively. ``        ``float` `median;``        ``if` `(n % ``2` `!= ``0``) ``        ``{``            ``median = b[n / ``2``];``        ``}``        ``else``        ``{``            ``median = (``float``) ((b[(n - ``1``) / ``2``]``                    ``+ b[(n / ``2``)]) / ``2.0``);``        ``}`` ` `        ``// Output the result ``        ``System.out.println(``"median = "` `+ median);``        ``System.out.println(``"mode = "` `+ mode);``    ``}`` ` `// Driver program ``public` `static` `void` `main(String[] args)``{``    ``int` `a[] = {``1``, ``4``, ``1``, ``2``, ``7``, ``1``, ``2``, ``5``, ``3``, ``6``};``    ``int` `n = a.length;``    ``printModeMedian(a, n);`` ` `}``}`` ` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for Mode and Median ``# using Counting Sort technique `` ` `# Function that sort input array a[] and ``# calculate mode and median using counting sort ``def` `printModeMedian(a, n):`` ` `    ``# The output array b[] will ``    ``# have sorted array``    ``b ``=` `[``0``] ``*` `n `` ` `    ``# Variable to store max of input array``    ``# which will to have size of count array ``    ``Max` `=` `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` `+` `1``    ``count ``=` `[``0``] ``*` `t`` ` `    ``# 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 `` ` `    ``# Update count[] array with sum``    ``for` `i ``in` `range``(``1``, t):``        ``count[i] ``=` `count[i] ``+` `count[i ``-` `1``]`` ` `    ``# Sorted output array b[] ``    ``# to calculate median ``    ``for` `i ``in` `range``(n):``        ``b[count[a[i]] ``-` `1``] ``=` `a[i]``        ``count[a[i]] ``-``=` `1`` ` `    ``# Median according to odd and even ``    ``# array size respectively.``    ``median ``=` `0.0``    ``if` `(n ``%` `2` `!``=` `0``):``        ``median ``=` `b[n ``/``/` `2``]``    ``else``:``        ``median ``=` `((b[(n ``-` `1``) ``/``/` `2``] ``+` `                   ``b[n ``/``/` `2``]) ``/` `2.0``)`` ` `    ``# Output the result``    ``print``(``"median ="``, median)``    ``print``(``"mode ="``, mode)`` ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:`` ` `    ``arr ``=` `[ ``1``, ``4``, ``1``, ``2``, ``7``, ``1``, ``2``, ``5``, ``3``, ``6``]``    ``n ``=` `len``(arr)`` ` `    ``printModeMedian(arr, n)``     ` `# This code is contributed by himanshu77`

## C#

 `// C# Program for Mode and ``// Median using Counting ``// Sort technique ``using` `System;``using` `System.Linq;`` ` `class` `GFG ``{``    ``// function that sort input array a[] and ``    ``// calculate mode and median using counting ``    ``// sort. ``    ``static` `void` `printModeMedian(``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;``            ``}``        ``}`` ` `        ``// Update count[] array with sum ``        ``for` `(``int` `i = 1; i < t; i++)``        ``{``            ``count[i] = count[i] + count[i - 1];``        ``}`` ` `        ``// Sorted output array b[] ``        ``// to calculate median ``        ``for` `(``int` `i = 0; i < n; i++) ``        ``{``            ``b[count[a[i]] - 1] = a[i];``            ``count[a[i]]--;``        ``}`` ` `        ``// Median according to odd and even ``        ``// array size respectively. ``        ``float` `median;``        ``if` `(n % 2 != 0) ``        ``{``            ``median = b[n / 2];``        ``}``        ``else``        ``{``            ``median = (``float``) ((b[(n - 1) / 2] + ``                               ``b[(n / 2)]) / 2.0);``        ``}`` ` `        ``// Output the result ``        ``Console.WriteLine(``"median = "` `+ median);``        ``Console.WriteLine(``"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;``    ``printModeMedian(a, n);``}``}`` ` `// This code is contributed by Rajput-Ji`

## PHP

 ` ``\$k``)``        ``{``            ``\$k` `= ``\$count``[``\$i``];``            ``\$mode` `= ``\$i``;``        ``}``    ``} `` ` `    ``// Update count[] array with sum``    ``for` `(``\$i` `= 1; ``\$i` `< ``\$t``; ``\$i``++)``        ``\$count``[``\$i``] = ``\$count``[``\$i``] + ``\$count``[``\$i` `- 1];`` ` `    ``// Sorted output array b[]``    ``// to calculate median``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)``    ``{``        ``\$b``[``\$count``[``\$a``[``\$i``]] - 1] = ``\$a``[``\$i``];``        ``\$count``[``\$a``[``\$i``]]--;``    ``}``     ` `    ``// Median according to odd and even ``    ``// array size respectively.``    ``\$median``;``    ``if` `(``\$n` `% 2 != 0)``        ``\$median` `= ``\$b``[``\$n` `/ 2];``    ``else``        ``\$median` `= (``\$b``[(``\$n` `- 1) / 2] + ``                   ``\$b``[(``\$n` `/ 2)]) / 2.0;``     ` `    ``// Output the result ``    ``echo` `"median = "``, ``\$median``, ``"\n"` `;``    ``echo` `"mode = "` `, ``\$mode``;``}`` ` `// Driver Code``\$a` `= ``array``( 1, 4, 1, 2, 7, ``            ``1, 2, 5, 3, 6 );``\$n` `= sizeof(``\$a``);``printModeMedian(``\$a``, ``\$n``);`` ` `// This code is contributed by jit_t``?>`

Output:
```median = 2.5
mode = 1
```

Time Complexity = O(N + P), where N is the time for input array and P is time for count array.
Space Complexity = O(P), where P is the size of auxiliary array.

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.

My Personal Notes arrow_drop_up