Median of two sorted arrays of different sizes

This is an extension of median of two sorted arrays of equal size problem. Here we handle arrays of unequal size also.

Method 1: (Linear and Simpler Approach)
Here we need to find the median of the two sorted arrays of different sizes so we keep two variables to point to the arrays and one used to count the no of elements read. We used a simple Merge based O(n) solution just we are not merging the array instead we are keeping track of the last element read till we reach the median
There are two cases :
Case 1: m+n is odd
Then we will find a clear median at (m+n)/2 index in the array obtained after merging both the arrays so we just traverse both the arrays and keep the last value in m1 after the loop, m1 will contain the value of the median
Case 2: m+n is even
Median will be average of elements at index ((m+n)/2 – 1) and (m+n)/2 in the array obtained after merging both the arrays so we need to keep track of not only the last element but also the second last element (m2 is used for this) so we traverse both the arrays and keep the last value in m1 and second last value in m2 after the loop, (m1+m2)/2 will contain the value of the median.

Below is the implementation of above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// A Simple Merge based O(n) solution to find 
// median of two sorted arrays 
#include <stdio.h> 
  
/* This function returns median of ar1[] and ar2[]. 
Assumption in this function: 
Both ar1[] and ar2[] are sorted arrays */
int getMedian(int ar1[], int ar2[], int n, int m) 
    int i = 0; /* Current index of input array ar1[] */
    int j = 0; /* Current index of input array ar2[] */
    int count; 
    int m1 = -1, m2 = -1; 
  
    // Since there are (n+m) elements, 
    // There are following two cases
    // if n+m is odd then the middle 
    //index is median i.e. (m+n)/2
    if((m + n) % 2 == 1) {
        for (count = 0; count <= (n + m)/2; count++) {
            if(i != n && j != m){
            m1 = (ar1[i] > ar2[j]) ? ar2[j++] : ar1[i++];
            }
            else if(i < n){
            m1 = ar1[i++];
            }
            // for case when j<m,
            else{
            m1 = ar1[j++];
            }
        }
        return m1;
    }
      
    // median will be average of elements 
    // at index ((m+n)/2 - 1) and (m+n)/2
    // in the array obtained after merging ar1 and ar2
    else {
        for (count = 0; count <= (n + m)/2; count++) {
            m2 = m1;
            if(i != n && j != m){
            m1 = (ar1[i] > ar2[j]) ? ar2[j++] : ar1[i++];
            }
            else if(i < n){
            m1 = ar1[i++];
            }
            // for case when j<m,
            else{
            m1 = ar1[j++];
            }
        }
        return (m1 + m2)/2;
    }
}
  
/* Driver program to test above function */
int main() 
    int ar1[] = {900}; 
    int ar2[] = {5, 8, 10, 20}; 
  
    int n1 = sizeof(ar1)/sizeof(ar1[0]); 
    int n2 = sizeof(ar2)/sizeof(ar2[0]); 
    printf("%d", getMedian(ar1, ar2, n1, n2)); 
    getchar(); 
    return 0; 
// This code is uploaded by Pratil

chevron_right


Output:



 10 

Method 2: (Effective but a little Complex Approach)
The approach discussed in this post is similar to method 2 of equal the size post. The basic idea is same, we find the median of two arrays and compare the medians to discard almost half of the elements in both arrays. Since the number of elements may differ here, there are many base cases that need to be handled separately. Before we proceed to complete solution, let us first talk about all base cases.

Let the two arrays be A[N] and B[M]. In the following explanation, it is assumed that N is smaller than or equal to M.

Base cases:
The smaller array has only one element
Case 0: N = 0, M = 2
Case 1: N = 1, M = 1.
Case 2: N = 1, M is odd
Case 3: N = 1, M is even
The smaller array has only two elements
Case 4: N = 2, M = 2
Case 5: N = 2, M is odd
Case 6: N = 2, M is even

Case 0: There are no elements in first array, return median of second array. If second array is also empty, return -1.

Case 1: There is only one element in both arrays, so output the average of A[0] and B[0].

Case 2: N = 1, M is odd
Let B[5] = {5, 10, 12, 15, 20}
First find the middle element of B[], which is 12 for above array. There are following 4 sub-cases.
2.1 If A[0] is smaller than 10, the median is average of 10 and 12.
2.2 If A[0] lies between 10 and 12, the median is average of A[0] and 12.
2.3 If A[0] lies between 12 and 15, the median is average of 12 and A[0].
2.4 If A[0] is greater than 15, the median is average of 12 and 15.
In all the sub-cases, we find that 12 is fixed. So, we need to find the median of B[ M / 2 – 1 ], B[ M / 2 + 1], A[ 0 ] and take its average with B[ M / 2 ].

Case 3: N = 1, M is even
Let B[4] = {5, 10, 12, 15}
First find the middle items in B[], which are 10 and 12 in above example. There are following 3 sub-cases.
3.1 If A[0] is smaller than 10, the median is 10.
3.2 If A[0] lies between 10 and 12, the median is A[0].
3.3 If A[0] is greater than 12, the median is 12.
So, in this case, find the median of three elements B[ M / 2 – 1 ], B[ M / 2] and A[ 0 ].

Case 4: N = 2, M = 2
There are four elements in total. So we find the median of 4 elements.

Case 5: N = 2, M is odd
Let B[5] = {5, 10, 12, 15, 20}
The median is given by median of following three elements: B[M/2], max(A[0], B[M/2 – 1]), min(A[1], B[M/2 + 1]).

Case 6: N = 2, M is even
Let B[4] = {5, 10, 12, 15}
The median is given by median of following four elements: B[M/2], B[M/2 – 1], max(A[0], B[M/2 – 2]), min(A[1], B[M/2 + 1])



Remaining Cases:
Once we have handled the above base cases, following is the remaining process.
1) Find the middle item of A[] and middle item of B[].
…..1.1) If the middle item of A[] is greater than middle item of B[], ignore the last half of A[], let length of ignored part is idx. Also, cut down B[] by idx from the start.
…..1.2) else, ignore the first half of A[], let length of ignored part is idx. Also, cut down B[] by idx from the last.

Following is implementation of the above approach.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// A C++ program to find median of two sorted arrays of
// unequal sizes
#include <bits/stdc++.h>
using namespace std;
  
// A utility function to find median of two integers
float MO2(int a, int b)
{ return ( a + b ) / 2.0; }
  
// A utility function to find median of three integers
float MO3(int a, int b, int c)
{
    return a + b + c - max(a, max(b, c))
                     - min(a, min(b, c));
}
  
// A utility function to find median of four integers
float MO4(int a, int b, int c, int d)
{
    int Max = max( a, max( b, max( c, d ) ) );
    int Min = min( a, min( b, min( c, d ) ) );
    return ( a + b + c + d - Max - Min ) / 2.0;
}
  
// Utility function to find median of single array
float medianSingle(int arr[], int n)
{
   if (n == 0)
      return -1;
   if (n%2 == 0)
        return (double)(arr[n/2] + arr[n/2-1])/2;
   return arr[n/2];
}
  
// This function assumes that N is smaller than or equal to M
// This function returns -1 if both arrays are empty
float findMedianUtil( int A[], int N, int B[], int M )
{
    // If smaller array is empty, return median from second array
    if (N == 0)
      return medianSingle(B, M);
  
    // If the smaller array has only one element
    if (N == 1)
    {
        // Case 1: If the larger array also has one element,
        // simply call MO2()
        if (M == 1)
            return MO2(A[0], B[0]);
  
        // Case 2: If the larger array has odd number of elements,
        // then consider the middle 3 elements of larger array and
        // the only element of smaller array. Take few examples
        // like following
        // A = {9}, B[] = {5, 8, 10, 20, 30} and
        // A[] = {1}, B[] = {5, 8, 10, 20, 30}
        if (M & 1)
            return MO2( B[M/2], MO3(A[0], B[M/2 - 1], B[M/2 + 1]) );
  
        // Case 3: If the larger array has even number of element,
        // then median will be one of the following 3 elements
        // ... The middle two elements of larger array
        // ... The only element of smaller array
        return MO3( B[M/2], B[M/2 - 1], A[0] );
    }
  
    // If the smaller array has two elements
    else if (N == 2)
    {
        // Case 4: If the larger array also has two elements,
        // simply call MO4()
        if (M == 2)
            return MO4(A[0], A[1], B[0], B[1]);
  
        // Case 5: If the larger array has odd number of elements,
        // then median will be one of the following 3 elements
        // 1. Middle element of larger array
        // 2. Max of first element of smaller array and element
        //    just before the middle in bigger array
        // 3. Min of second element of smaller array and element
        //    just after the middle in bigger array
        if (M & 1)
            return MO3 ( B[M/2],
                         max(A[0], B[M/2 - 1]),
                         min(A[1], B[M/2 + 1])
                       );
  
        // Case 6: If the larger array has even number of elements,
        // then median will be one of the following 4 elements
        // 1) & 2) The middle two elements of larger array
        // 3) Max of first element of smaller array and element
        //    just before the first middle element in bigger array
        // 4. Min of second element of smaller array and element
        //    just after the second middle in bigger array
        return MO4 ( B[M/2],
                     B[M/2 - 1],
                     max( A[0], B[M/2 - 2] ),
                     min( A[1], B[M/2 + 1] )
                   );
    }
  
    int idxA = ( N - 1 ) / 2;
    int idxB = ( M - 1 ) / 2;
  
     /* if A[idxA] <= B[idxB], then median must exist in
        A[idxA....] and B[....idxB] */
    if (A[idxA] <= B[idxB] )
      return findMedianUtil(A + idxA, N/2 + 1, B, M - idxA );
  
    /* if A[idxA] > B[idxB], then median must exist in
       A[...idxA] and B[idxB....] */
    return findMedianUtil(A, N/2 + 1, B + idxA, M - idxA );
}
  
// A wrapper function around findMedianUtil(). This function
// makes sure that smaller array is passed as first argument
// to findMedianUtil
float findMedian( int A[], int N, int B[], int M )
{
    if (N > M)
       return findMedianUtil( B, M, A, N );
  
    return findMedianUtil( A, N, B, M );
}
  
// Driver program to test above functions
int main()
{
    int A[] = {900};
    int B[] = {5, 8, 10, 20};
  
    int N = sizeof(A) / sizeof(A[0]);
    int M = sizeof(B) / sizeof(B[0]);
  
    printf("%f", findMedian( A, N, B, M ) );
    return 0;
}

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// A PHP program to find median 
// of two sorted arrays of 
// unequal sizes
  
// A utility function to
// find median of two integers
function MO2($a, $b)
    return ($a + $b) / 2.0;
}
  
// A utility function to 
// find median of three integers
function MO3($a, $b, $c)
{
    return $a + $b + $c
       max($a, max($b, $c)) -
       min($a, min($b, $c));
}
  
// A utility function to find
// median of four integers
function MO4($a, $b, $c, $d)
{
    $Max = max($a, max($b, max($c, $d)));
    $Min = min($a, min($b, min( $c, $d)));
    return ($a + $b + $c + $d - $Max - $Min) / 2.0;
}
  
// Utility function to
// find median of single array
function medianSingle($arr, $n)
{
if ($n == 0)
    return -1;
if ($n % 2 == 0)
        return ($arr[$n / 2] + 
                $arr[$n / 2 - 1]) / 2;
return $arr[$n / 2];
}
  
// This function assumes that N 
// is smaller than or equal to M
// This function returns -1 if
// both arrays are empty
function findMedianUtil(&$A, $N, &$B, $M )
{
    // If smaller array is empty,
    // return median from second array
    if ($N == 0)
    return medianSingle($B, $M);
  
    // If the smaller array 
    // has only one element
    if ($N == 1)
    {
        // Case 1: If the larger
        // array also has one 
        // element, simply call MO2()
        if ($M == 1)
            return MO2($A[0], $B[0]);
  
        // Case 2: If the larger array 
        // has odd number of elements,
        // then consider the middle 3
        // elements of larger array and
        // the only element of smaller
        // array. Take few examples
        // like following
        // $A = array(9), 
        // $B = array(5, 8, 10, 20, 30) 
        // and $A = array(1),
        // $B = array(5, 8, 10, 20, 30)
        if ($M & 1)
            return MO2($B[$M / 2], $MO3($A[0], 
                       $B[$M / 2 - 1], 
                       $B[$M / 2 + 1]));
  
        // Case 3: If the larger array 
        // has even number of element,
        // then median will be one of 
        // the following 3 elements
        // ... The middle two elements
        //     of larger array
        // ... The only element of 
        //     smaller array
        return MO3($B[$M / 2], 
                   $B[$M / 2 - 1], $A[0]);
    }
  
    // If the smaller array
    // has two elements
    else if ($N == 2)
    {
        // Case 4: If the larger 
        // array also has two elements,
        // simply call MO4()
        if ($M == 2)
            return MO4($A[0], $A[1],
                       $B[0], $B[1]);
  
        // Case 5: If the larger array
        // has odd number of elements,
        // then median will be one of 
        // the following 3 elements
        // 1. Middle element of 
        //    larger array
        // 2. Max of first element of 
        //    smaller array and element
        // just before the middle 
        // in bigger array
        // 3. Min of second element 
        //    of smaller array and element
        // just after the middle 
        // in bigger array
        if ($M & 1)
            return MO3 ($B[$M / 2],
                        max($A[0], $B[$M / 2 - 1]),
                        min($A[1], $B[$M / 2 + 1]));
  
        // Case 6: If the larger array 
        // has even number of elements,
        // then median will be one of 
        // the following 4 elements
        // 1) & 2) The middle two 
        // elements of larger array
        // 3) Max of first element of 
        // smaller array and element
        // just before the first middle
        // element in bigger array
        // 4. Min of second element of 
        // smaller array and element
        // just after the second
        // middle in bigger array
        return MO4 ($B[$M / 2],
                    $B[$M / 2 - 1],
                    max($A[0], $B[$M / 2 - 2]),
                    min($A[1], $B[$M / 2 + 1]));
    }
  
    $idxA = ($N - 1 ) / 2;
    $idxB = ($M - 1 ) / 2;
  
    /* if $A[$idxA] <= $B[$idxB], then
        median must exist in
        $A[$idxA....] and $B[....$idxB] */
    if ($A[$idxA] <= $B[$idxB] )
    return findMedianUtil($A + $idxA
                          $N / 2 + 1, $B
                          $M - $idxA );
  
    /* if $A[$idxA] > $B[$idxB], 
    then median must exist in
    $A[...$idxA] and $B[$idxB....] */
    return findMedianUtil($A, $N/2 + 1, 
                          $B + $idxA, $M - $idxA );
}
  
// A wrapper function around
// findMedianUtil(). This 
// function makes sure that 
// smaller array is passed as 
// first argument to findMedianUtil
function findMedian(&$A, $N
                    &$B, $M )
{
    if ($N > $M)
    return findMedianUtil($B, $M
                          $A, $N );
  
    return findMedianUtil($A, $N
                          $B, $M );
}
  
// Driver Code
$A = array(900);
$B = array(5, 8, 10, 20);
  
$N = sizeof($A);
$M = sizeof($B);
  
echo findMedian( $A, $N, $B, $M );
  
// This code is contributed
// by ChitraNayal
?>

chevron_right



Output:

 10 

Time Complexity: O(LogM + LogN)

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up

Improved By : ChitraNayal, pratil, Raj Bansal