# Find Median of the Array formed from given frequencies of elements

• Difficulty Level : Medium
• Last Updated : 28 Apr, 2022

Given an array A[] containing N elements of an array and their frequency in that array (say arr[]), the task is to find the median of the array whose elements and frequency are given.

Note: Median of an array is the element at the middle of the sorted array

Examples:

Input: A[] = { {1, 2}, {4, 2}, {5, 1} }
Output:
Explanation: The array whose elements are given is {1, 1, 4, 4, 5}.
Therefore, the median of the array will be 4.

Input: A[] = { {3, 4}, {2, 3}, {9, 2} }
Output: 3
Explanation: The newly created array will be {2, 2, 2, 3, 3, 3, 3, 9, 9}.
Therefore the median of the array will be 3.

Naive Approach: The basic approach is to create the array and then sort the array and find the middle element of that array.

Time Complexity: O(M * log M)  where M is the sum of the frequencies of all elements given in A[].
Auxiliary Space: O(M)

Efficient approach: As the sum of frequencies of the elements present in A[] can be very large it is not feasible to build an array. This can be solved efficiently based on the following idea:

Sort the array A[] based on the value of elements. Now calculate the total number of elements that will be in the array formed from these elements (say M). The element at M/2 th position is the median.
So iterate from the minimum elements and with the help of their frequencies find out the element and M/2 th position.

Follow the below steps to implement the above idea:

• Insert all the elements in a map with the elements as the key and their frequency as value (a map is sorted based on the value of the key. Therefore it satisfies the need of sorting).
• Count total elements that will be in the array.
• Iterate from the minimum elements and check if the total elements till the current value is the same as M/2:
• If it is same, then the current element is the required median.
• Otherwise, increase the total number of elements till now.
• Return the median.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach` `#include ``using` `namespace` `std;` `// Find median of the newly created array``int` `findMedian(vector > a, ``int` `n)``{``    ``map<``int``, ``int``> m;` `    ``// Size of the newly created array``    ``int` `totalsize = 0;` `    ``// Put all elements in the map``    ``for` `(``int` `i = 0; i < n; i++) {``        ``int` `val = a[i][0];``        ``int` `time` `= a[i][1];``        ``m[val] += ``time``;``        ``totalsize += ``time``;``    ``}` `    ``// Find the element present at the middle``    ``// of the newly created array``    ``int` `meidanpos = totalsize / 2;``    ``long` `long` `pos = 0;``    ``for` `(``auto` `it : m) {` `        ``// If the pos + current element times``        ``// is greater than medianpos``        ``// then return current element``        ``if` `(pos + it.second > meidanpos) {``            ``return` `it.first;``        ``}``        ``else` `{``            ``pos += it.second;``        ``}``    ``}``}` `// Driver Code``int` `main()``{``    ``vector > A;``    ``A = { { 1, 2 }, { 4, 2 }, { 5, 1 } };``    ``int` `N = A.size();` `    ``// Function call``    ``cout << findMedian(A, N);``    ``return` `0;``}`

## Java

 `// Java code to implement the approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG``{` `  ``// Find median of the newly created array``  ``public` `static` `int` `findMedian(``int` `a[][], ``int` `n)``  ``{``    ``TreeMap m``      ``= ``new` `TreeMap();` `    ``// Size of the newly created array``    ``int` `totalsize = ``0``;` `    ``// Put all elements in the map``    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``int` `val = a[i][``0``];``      ``int` `time = a[i][``1``];``      ``if` `(m.get(val) != ``null``)``        ``m.put(val, m.get(val) + time);``      ``else``        ``m.put(val, time);``      ``totalsize += time;``    ``}` `    ``// Find the element present at the middle``    ``// of the newly created array``    ``int` `meidanpos = totalsize / ``2``;``    ``long` `pos = ``0``;``    ``for` `(Map.Entry it :``         ``m.entrySet()) {` `      ``// If the pos + current element times``      ``// is greater than medianpos``      ``// then return current element``      ``if` `(pos + it.getValue() > meidanpos) {``        ``return` `it.getKey();``      ``}``      ``else` `{``        ``pos += it.getValue();``      ``}``    ``}``    ``return` `0``;``  ``}` `  ``public` `static` `void` `main(String[] args)``  ``{` `    ``int` `A[][] = { { ``1``, ``2` `}, { ``4``, ``2` `}, { ``5``, ``1` `} };``    ``int` `N = A.length;` `    ``// Function call``    ``System.out.print(findMedian(A, N));``  ``}``}` `// This code is contributed by Rohit Pradhan`

## Python3

 `# Python3 code to implement the approach` `# Find median of the newly created array``def` `findMedian(a, n):``    ``m ``=` `dict``()``    ` `    ``# Size of the newly created array``    ``totalsize ``=` `0``    ` `    ``# Put all elements in the map``    ``for` `i ``in` `range``(n):``        ``val ``=` `a[i][``0``]``        ``time ``=` `a[i][``1``]``        ``if` `val ``in` `m:``            ``m[val] ``+``=` `time``        ``else``:``            ``m[val] ``=` `time``        ``totalsize ``+``=` `time``    ` `    ``# find the element present at the middle``    ``# of the newly created array``    ``medianpos ``=` `totalsize ``/``/` `2``    ``pos ``=` `0``    ` `    ``for` `it ``in` `m.items():``        ``# if the pos + current element times``        ``# is greater than medianpos``        ``# then return the current element``        ``if` `pos ``+` `it[``1``] > medianpos:``            ``return` `it[``0``]``        ``else``:``            ``pos ``+``=` `it[``1``]` `# Driver Code``A ``=` `[[``1``, ``2``], [``4``, ``2``], [``5``, ``1``]]``N ``=` `len``(A)` `# Function Call``print``(findMedian(A, N))``              ` `# This code is contributed by phasing17`

## C#

 `// C# program to implement the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``   ``// Find median of the newly created array``  ``static` `int` `findMedian(``int``[,] a, ``int` `n)``  ``{``    ` `     ``Dictionary<``int``,``int``> m = ``new` `Dictionary<``int``,``int``>();`` ` `    ``// Size of the newly created array``    ``int` `totalsize = 0;`` ` `    ``// Put all elements in the map``    ``for` `(``int` `i = 0; i < n; i++) {``      ``int` `val = a[i,0];``      ``int` `time = a[i,1];``      ``if` `(m.ContainsKey(val))``        ``m[val]=m[val] + time;``      ``else``        ``m[val]=time;``      ``totalsize += time;``    ``}`` ` `    ``// Find the element present at the middle``    ``// of the newly created array``    ``int` `meidanpos = totalsize / 2;``    ``long` `pos = 0;``    ``foreach``(KeyValuePair<``int``, ``int``> it ``in` `m)``    ``{``      ``// If the pos + current element times``      ``// is greater than medianpos``      ``// then return current element``      ``if` `(pos + it.Value > meidanpos) {``        ``return` `it.Key;``      ``}``      ``else` `{``        ``pos += it.Value;``      ``}``    ``}``    ``return` `0;``  ``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int``[,] A = { { 1, 2 }, { 4, 2 }, { 5, 1 } };``    ``int` `N = A.GetLength(0);;`` ` `    ``// Function call``    ``Console.Write(findMedian(A, N));``}``}` `// This code is contributed by Pushpesh Raj`

## Javascript

 ``

Output

`4`

Time Complexity: O(N * logN)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up