# Program to find weighted median of a given array

Last Updated : 21 Jun, 2021

Given two arrays arr[] of N integers and W[] of N weights where W[i] is the weight for the element arr[i]. The task is to find the weighted median of the given array.

Note: The sum of the weight of all elements will always be 1.

Let the array arr[] be arranged in increasing order with their corresponding weights.

If N is odd, then there is only one weighted median say arr[k] which satisfies the below property:

If N is even, then there are two weighted medians, i.e., lower and upper weighted median.

The lower weighted median for element arr[k] which satisfies the following:

The upper weighted median for element arr[k] which satisfies the following:

Examples:

Input: arr={5, 1, 3, 2, 4}, W=[0.25, 0.15, 0.2, 0.1, 0.3]
Output: The weighted median is element 4
Explanation:
Here the number of element is odd, so there is only one weighted median because at K = 3 the above condition is satisfied.
The cumulative weights on each side of element 4 is 0.45 and 0.25.

Input: arr=[4, 1, 3, 2], W=[0.25, 0.49, 0.25, 0.01]
Output:
The lower weighted median is element 2
The upper weighted median is element 3
Explanation:
Here there are an even number of elements, so there are two weighted medians.
Lower weighted median is at K = 2 because at K = 2 the above condition is satisfied with cumulative weight on each side of element 2 is 0.49 and 0.5.
Upper weighted median is at K = 3 because at K = 3 the above condition is satisfied with cumulative weight on each side of element 3 is 0.5 and 0.25.

Approach: Follow the steps below to solve the given problem:

1. Now to find the median of the array arr[] in increasing order with their respective order of weight shouldn’t be changed.
2. So, create a set of pairs where the first element of the pair will be arr[i] and the second element of the pair will be its corresponding weights W[i].
3. Then sort the set of Pairs according to the arr[] values.
4. If the number of pairs is odd, then find the weighted median as:
• Traverse over the set of pairs and compute sum by adding weights.
• When the sum becomes greater than 0.5 print the arr[i] value of that Pair.
5. But, if the number of pairs is even, then find both lower and upper weighted medians:
• For the lower median traverse over the set pairs from the left and compute sum by adding weights.
• When the sum becomes greater than or equal to 0.5 print the arr[i] value of that Pair.
• For the upper median traverse over the set pairs from the right and compute sum by adding weights.
• When the sum becomes greater than or equal to 0.5 print the arr[i] value of that Pair.

Below is the implementation of the above approach:

## C++14

 // C++ program for the above approach#include using namespace std; // Function to calculate weighted medianvoid weightedMedian(vector<int> arr,                    vector<float> W){         // Store pr of arr[i] and W[i]    vector> pr;     for(int index = 0;             index < arr.size();             index++)        pr.push_back({arr[index],                         W[index]});     // Sort the list of pr w.r.t.    // to their arr[] values    sort(pr.begin(), pr.end());         // If N is odd    if (arr.size() % 2 != 0)    {                 // Traverse the set pr        // from left to right        float sums = 0;        for(auto element : pr)        {                         // Update sums            sums += element.second;             // If sum becomes > 0.5            if (sums > 0.5)                cout << "The Weighted Median is element "                     << element.first << endl;        }    }           // If N is even    else    {                 // For lower median traverse        // the set pr from left        float sums = 0;        for(auto element : pr)        {                         // Update sums            sums += element.second;             // When sum >= 0.5            if (sums >= 0.5)            {                cout << "Lower Weighted Median is element "                     << element.first << endl;                break;            }        }                 // For upper median traverse        // the set pr from right        sums = 0;        for(int index = pr.size() - 1;                index >= 0;                 index--)        {            int element = pr[index].first;            float weight = pr[index].second;             // Update sums            sums += weight;             // When sum >= 0.5            if (sums >= 0.5)            {                cout << "Upper Weighted Median is element "                     << element;                break;            }        }    }} // Driver Codeint main(){         // Given array arr[]    vector<int> arr = { 4, 1, 3, 2 };         // Given weights W[]    vector<float> W = { 0.25, 0.49, 0.25, 0.01 };         // Function Call    weightedMedian(arr, W);} // This code is contributed by mohit kumar 29

## Java

 // Java program for the// above approachimport java.util.*;class GFG{ static class Pair implements Comparable{  int first;  double second;   Pair(int f, double s)  {    first = f;    second = s;  }   @Override  public int compareTo(Pair o)  {    if(this.second > o.second)      return 1;    else if(this.second == o.second)      return 0;    return -1;  }} // Function to calculate weighted medianstatic void weightedMedian(Vector arr,                           Vector W){  // Store pr of arr[i] and W[i]  Vector pr = new Vector<>();   for(int index = 0;       index < arr.size();       index++)    pr.add(new Pair(arr.get(index),                    W.get(index)));   // Sort the list of pr w.r.t.  // to their arr[] values  Collections.sort(pr);   // If N is odd  if (arr.size() % 2 != 0)  {    // Traverse the set pr    // from left to right    float sums = 0;    for(Pair element : pr)    {      // Update sums      sums += element.second;       // If sum becomes > 0.5      if (sums > 0.5)        System.out.print(               "The Weighted Median is element " +                 element.first + "\n");    }  }   // If N is even  else  {    // For lower median traverse    // the set pr from left    double sums = 0;    for(Pair element : pr)    {      // Update sums      sums += element.second;       // When sum >= 0.5      if (sums <= 0.5)      {        System.out.print(               "Lower Weighted Median is element " +                 element.first + "\n");        break;      }    }     // For upper median traverse    // the set pr from right    sums = 0;    for(int index = pr.size() - 1;            index >= 0; index--)    {      int element = pr.get(index).first;      double weight = pr.get(index).second;       // Update sums      sums += weight;       // When sum >= 0.5      if (sums >= 0.5)      {        System.out.print(               "Upper Weighted Median is element " +                 element);        break;      }    }  }} // Driver Codepublic static void main(String[] args){      // Given array arr[]  Vector arr = new Vector<>();  arr.add(4);  arr.add(1);  arr.add(3);  arr.add(2);   // Given weights W[]  Vector W =   new Vector<>();  W.add(0.25);  W.add(0.49);  W.add(0.25);  W.add(0.01);   // Function Call  weightedMedian(arr, W);}} // This code is contributed by gauravrajput1

## Python3

 # Python3 program for the above approach # Function to calculate weighted mediandef weightedMedian(arr, W):     # Store pairs of arr[i] and W[i]    pairs = []         for index in range(len(arr)):        pairs.append([arr[index], W[index]])     # Sort the list of pairs w.r.t.    # to their arr[] values    pairs.sort(key = lambda p: p[0])     # If N is odd    if len(arr) % 2 != 0:         # Traverse the set pairs        # from left to right        sums = 0        for element, weight in pairs:                     # Update sums            sums += weight             # If sum becomes > 0.5            if sums > 0.5:                print("The Weighted Median", end = ' ')                print("is element {}".format(element))     # If N is even    else:         # For lower median traverse        # the set pairs from left        sums = 0        for element, weight in pairs:                         # Update sums            sums += weight             # When sum >= 0.5            if sums >= 0.5:                print("Lower Weighted Median", end = ' ')                print("is element {}".format(element))                break         # For upper median traverse        # the set pairs from right        sums = 0        for index in range(len(pairs)-1, -1, -1):                     element = pairs[index][0]            weight = pairs[index][1]                         # Update sums            sums += weight             # When sum >= 0.5            if sums >= 0.5:                print("Upper Weighted Median", end = ' ')                print("is element {}".format(element))                break # Driver Codeif __name__ == "__main__":         # Given array arr[]    arr = [4, 1, 3, 2]         # Given weights W[]    W = [0.25, 0.49, 0.25, 0.01]     # Function Call    weightedMedian(arr, W)

## C#

 // C# program for the above approachusing System;using System.Collections.Generic; class GFG{     // Function to calculate weighted medianstatic void weightedMedian(int[] arr,                           float[] W){         // Store pr of arr[i] and W[i]    List> pr = new List>();      for(int index = 0; index < arr.Length; index++)        pr.Add(new Tuple<int, float>(arr[index], W[index]));      // Sort the list of pr w.r.t.    // to their arr[] values    pr.Sort();          // If N is odd    if (arr.Length % 2 != 0)    {                 // Traverse the set pr        // from left to right        float sums = 0;        foreach(Tuple<int, float> element in pr)        {                         // Update sums            sums += element.Item2;              // If sum becomes > 0.5            if (sums > 0.5)                Console.WriteLine("The Weighted Median " +                                  "is element " + element.Item1);        }    }            // If N is even    else    {                 // For lower median traverse        // the set pr from left        float sums = 0;        foreach(Tuple<int, float> element in pr)        {                         // Update sums            sums += element.Item2;              // When sum >= 0.5            if (sums >= 0.5)            {                Console.WriteLine("Lower Weighted Median " +                                  "is element " + element.Item1);                break;            }        }                  // For upper median traverse        // the set pr from right        sums = 0;        for(int index = pr.Count - 1; index >= 0; index--)        {            int element = pr[index].Item1;            float weight = pr[index].Item2;              // Update sums            sums += weight;              // When sum >= 0.5            if (sums >= 0.5)            {                Console.Write("Upper Weighted Median " +                                "is element " + element);                break;            }        }    }} // Driver codestatic void Main(){         // Given array arr[]    int[] arr = { 4, 1, 3, 2 };          // Given weights W[]    float[] W = { 0.25f, 0.49f, 0.25f, 0.01f };          // Function Call    weightedMedian(arr, W);}} // This code is contributed by divyeshrabadiya07

## Javascript

 

Output:
Lower Weighted Median is element 2
Upper Weighted Median is element 3

Time Complexity: O(N log N)
Auxiliary Space: O(N)

Previous
Next