Skip to content
Related Articles

Related Articles

Find Median of the Array formed from given frequencies of elements

View Discussion
Improve Article
Save Article
  • 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 <bits/stdc++.h>
using namespace std;
 
// Find median of the newly created array
int findMedian(vector<vector<int> > 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<vector<int> > 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<Integer, Integer> m
      = new TreeMap<Integer, Integer>();
 
    // 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<Integer, Integer> 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




<script>
 
// JavaScript code to implement the approach
 
// Find median of the newly created array
function findMedian(a, n){
    let m = new Map()
     
    // Size of the newly created array
    let totalsize = 0
     
    // Put all elements in the map
    for(let i = 0; i < n; i++){
                 
        let val = a[i][0]
        let time = a[i][1]
        if(m.has(val))
            m.set(val,m.get(val)+time)
        else
            m.set(val,time)
        totalsize += time
    }
     
    // find the element present at the middle
    // of the newly created array
    let medianpos = Math.floor(totalsize / 2)
    let pos = 0
     
    for(let [it,it2] of m)
    {
     
        // if the pos + current element times
        // is greater than medianpos
        // then return the current element
        if(pos + it2 > medianpos)
            return it
        else
            pos += it2
    }
}
 
// Driver Code
let A = [[1, 2], [4, 2], [5, 1]]
let N = A.length
 
// Function Call
document.write(findMedian(A, N))
               
// This code is contributed by shinjanpatra
 
</script>


Output

4

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!