 Open in App
Not now

# Program to find weighted median of a given array

• Difficulty Level : Medium
• 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 median void 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 Code int 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 approach import 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 median static 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 Code public 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 median def 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)       # 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]             weight = pairs[index]                           # Update sums             sums += weight               # When sum >= 0.5             if sums >= 0.5:                 print("Upper Weighted Median", end = ' ')                 print("is element {}".format(element))                 break   # Driver Code if __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 approach using System; using System.Collections.Generic;   class GFG{       // Function to calculate weighted median static 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 code static 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)

My Personal Notes arrow_drop_up
Related Articles