Median of two sorted arrays of different sizes - GeeksforGeeks

19 Feb, 2022
Given two sorted arrays, a[] and b[], the task is to find the median of these sorted arrays, in O(log n + log m) time complexity, when n is the number of elements in the first array, and m is the number of elements in the second array. This is an extension of median of two sorted arrays of equal size problem. Here we handle arrays of unequal size also.
Example: 
Input: ar1[] = {-5, 3, 6, 12, 15}
        ar2[] = {-12, -10, -6, -3, 4, 10}
Output : The median is 3.
Explanation : The merged array is :
        ar3[] = {-12, -10, -6, -5 , -3,
                 3, 4, 6, 10, 12, 15},
       So the median of the merged array is 3

Input: ar1[] = {2, 3, 5, 8}
        ar2[] = {10, 12, 14, 16, 18, 20}
Output : The median is 11.
Explanation : The merged array is :
        ar3[] = {2, 3, 5, 8, 10, 12, 14, 16, 18, 20}
        if the number of the elements are even, 
        so there are two middle elements,
        take the average between the two :
        (10 + 12) / 2 = 11.
Method 1: This method uses a linear and simpler approach. 
Approach: The given arrays are sorted, so merge the sorted arrays in an efficient way and keep the count of elements inserted in the output array or printed form. So when the elements in the output array are half the original size of the given array print the element as a median element. There are two cases: 
Case 1: m+n is odd, the median is at (m+n)/2 th index in the array obtained after merging both the arrays.Case 2: m+n is even, the 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
Case 1: m+n is odd, the median is at (m+n)/2 th index in the array obtained after merging both the arrays.
Case 2: m+n is even, the 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
Algorithm: 
Given two arrays are sorted. So they can be merged in O(m+n) time. Create a variable count to have a count of elements in the output array.If the value of (m+n) is odd then there is only one median else the median is the average of elements at index (m+n)/2 and ((m+n)/2 – 1).To merge the both arrays, keep two indices i and j initially assigned to 0. Compare the ith index of 1st array and jth index of second, increase the index of the smallest element and increase the count.Store (m+n)/2 and (m+n)/2-1 in two variables (In the below C++ code, m1 and m2 are used for this purpose).Check if the count reached (m+n) / 2. If (m+n) is odd return m1, If even return (m1+m2)/2.
Given two arrays are sorted. So they can be merged in O(m+n) time. Create a variable count to have a count of elements in the output array.
If the value of (m+n) is odd then there is only one median else the median is the average of elements at index (m+n)/2 and ((m+n)/2 – 1).
To merge the both arrays, keep two indices i and j initially assigned to 0. Compare the ith index of 1st array and jth index of second, increase the index of the smallest element and increase the count.
Store (m+n)/2 and (m+n)/2-1 in two variables (In the below C++ code, m1 and m2 are used for this purpose).
Check if the count reached (m+n) / 2. If (m+n) is odd return m1, If even return (m1+m2)/2.
Implementation: 
C++
C
Java
Python3
C#
Javascript
// A Simple Merge based O(n) solution to find// median of two sorted arrays#include <bits/stdc++.h>using namespace std;   /* 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;    /*loop till (m+n)/2*/    for (count = 0; count <= (m + n)/2; count++)    {        //store (n+m)/2-1 in m2        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 = ar2[j++];        }    }    // 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    // other wise 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    if((m + n) % 2 == 1){        return m1;    }    else{        return (m1+m2)/2;    }}/* Driver code */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]);    cout << getMedian(ar1, ar2, n1, n2);} // This is code is contributed by rathbhupendra, modified by rajesh999
// 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 = ar2[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
// A Simple Merge based O(n) solution// to find median of two sorted arraysclass GFG{     // Function to calculate medianstatic int getMedian(int ar1[], int ar2[],                     int n, int m){         // Current index of input array ar1[]    int i = 0;         // Current index of input array ar2[]    int j = 0;    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 = ar2[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 = ar2[j++];            }        }        return (m1 + m2) / 2;    }} // Driver codepublic static void main(String[] args){    int ar1[] = { 900 };    int ar2[] = { 5, 8, 10, 20 };     int n1 = ar1.length;    int n2 = ar2.length;     System.out.println(getMedian(ar1, ar2, n1, n2));}} // This code is contributed by Yash Singhal
# A Simple Merge based O(n) solution to find# median of two sorted arrays """ This function returns median of ar1[] and ar2[].Assumption in this function:Both ar1[] and ar2[] are sorted arrays """def getMedian(ar1, ar2, n, m) :     i = 0 # Current index of input array ar1[]    j = 0 # Current index of input array ar2[]    m1, m2 = -1, -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 in range(((n + m) // 2) + 1) :                   if(i != n and j != m) :                           if ar1[i] > ar2[j] :                    m1 = ar2[j]                    j += 1                else :                    m1 = ar1[i]                    i += 1                       elif(i < n) :                           m1 = ar1[i]                i += 1                      # for case when j<m,            else :                           m1 = ar2[j]                j += 1               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 in range(((n + m) // 2) + 1) :                    m2 = m1            if(i != n and j != m) :                       if ar1[i] > ar2[j] :                    m1 = ar2[j]                    j += 1                else :                    m1 = ar1[i]                    i += 1                       elif(i < n) :                           m1 = ar1[i]                i += 1                         # for case when j<m,            else :                           m1 = ar2[j]                j += 1               return (m1 + m2)//2 # Driver code     ar1 = [900]ar2 = [5, 8, 10, 20] n1 = len(ar1)n2 = len(ar2)print(getMedian(ar1, ar2, n1, n2)) # This code is contributed by divyesh072019
// A Simple Merge based O(n) solution// to find median of two sorted arraysusing System; class GFG{     // Function to calculate medianstatic int getMedian(int []ar1, int []ar2,                     int n, int m){         // Current index of input array ar1[]    int i = 0;         // Current index of input array ar2[]    int j = 0;         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 = ar2[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 = ar2[j++];            }        }        return (m1 + m2) / 2;    }} // Driver codepublic static void Main(String[] args){    int []ar1 = { 900 };    int []ar2 = { 5, 8, 10, 20 };     int n1 = ar1.Length;    int n2 = ar2.Length;     Console.WriteLine(getMedian(ar1, ar2, n1, n2));}} // This code is contributed by Princi Singh
<script> // A Simple Merge based O(n) solution to find// median of two sorted arrays // This function returns median of ar1[] and ar2[].// Assumption in this function:// Both ar1[] and ar2[] are sorted arraysfunction getMedian(ar1, ar2, n, m){         // Current index of input array ar1[]    let i = 0;         // Current index of input array ar2[]    let j = 0;    let count;    let 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 = ar2[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 = ar2[j++];            }        }        return (m1 + m2) / 2;    }}     // Driver codelet ar1 = [900];let ar2 = [5, 8, 10, 20]; let n1 = ar1.length;let n2 = ar2.length;document.write(getMedian(ar1, ar2, n1, n2)); // This code is contributed by divyeshrabadiya07 </script>
  
10
 
Complexity Analysis: 
 
Time Complexity: O(m + n). To merge both the arrays O(m+n) time is needed.
Space Complexity: O(1). No extra space is required.
 
Efficient solution: 
 
Approach:The idea is simple, calculate the median of both the arrays and discard one half of each array. Now, there are some basic corner cases. For array size less than or equal to 2 
 
Suppose there are two arrays and the size of both the arrays is greater than 2. Find the middle element of the first array and middle element of the second array (the first array is smaller than the second) if the middle element of the smaller array is less than the second array, then it can be said that all elements of the first half of smaller array will be in the first half of the output (merged array). So, reduce the search space by ignoring the first half of the smaller array and the second half of the larger array. Else ignore the second half of the smaller array and first half of a larger array.
 
In addition to that there are more basic corner cases: 
 
If the size of smaller array is 0. Return the median of a larger array.if the size of smaller array is 1. The size of the larger array is also 1. Return the median of two elements.If the size of the larger array is odd. Then after adding the element from 2nd array, it will be even so the median will be an average of two mid elements. So the element from the smaller array will affect the median if and only if it lies between (m/2 – 1)th and (m/2 + 1)th element of the larger array. So, find the median in between the four elements, the element of the smaller array and (m/2)th, (m/2 – 1)th and (m/2 + 1)th element of a larger arraySimilarly, if the size is even, then check for the median of three elements, the element of the smaller array and (m/2)th, (m/2 – 1)th element of a larger arrayIf the size of smaller array is 2 If the larger array also has two elements, find the median of four elements.If the larger array has an odd number of elements, then the median will be one of the following 3 elements Middle element of larger arrayMax of the second element of smaller array and element just before the middle, i.e M/2-1th element in a bigger arrayMin of the first element of smaller array and element just after the middle in the bigger array, i.e M/2 + 1th element in the bigger arrayIf the larger array has even number of elements, then the median will be one of the following 4 elements The middle two elements of the larger arrayMax of the first element of smaller array and element just before the first middle element in the bigger array, i.e M/2 – 2nd elementMin of the second element of smaller array and element just after the second middle in the bigger array, M/2 + 1th element
If the size of smaller array is 0. Return the median of a larger array.
if the size of smaller array is 1. The size of the larger array is also 1. Return the median of two elements.If the size of the larger array is odd. Then after adding the element from 2nd array, it will be even so the median will be an average of two mid elements. So the element from the smaller array will affect the median if and only if it lies between (m/2 – 1)th and (m/2 + 1)th element of the larger array. So, find the median in between the four elements, the element of the smaller array and (m/2)th, (m/2 – 1)th and (m/2 + 1)th element of a larger arraySimilarly, if the size is even, then check for the median of three elements, the element of the smaller array and (m/2)th, (m/2 – 1)th element of a larger array
The size of the larger array is also 1. Return the median of two elements.If the size of the larger array is odd. Then after adding the element from 2nd array, it will be even so the median will be an average of two mid elements. So the element from the smaller array will affect the median if and only if it lies between (m/2 – 1)th and (m/2 + 1)th element of the larger array. So, find the median in between the four elements, the element of the smaller array and (m/2)th, (m/2 – 1)th and (m/2 + 1)th element of a larger arraySimilarly, if the size is even, then check for the median of three elements, the element of the smaller array and (m/2)th, (m/2 – 1)th element of a larger array
The size of the larger array is also 1. Return the median of two elements.
If the size of the larger array is odd. Then after adding the element from 2nd array, it will be even so the median will be an average of two mid elements. So the element from the smaller array will affect the median if and only if it lies between (m/2 – 1)th and (m/2 + 1)th element of the larger array. So, find the median in between the four elements, the element of the smaller array and (m/2)th, (m/2 – 1)th and (m/2 + 1)th element of a larger array
Similarly, if the size is even, then check for the median of three elements, the element of the smaller array and (m/2)th, (m/2 – 1)th element of a larger array
If the size of smaller array is 2 If the larger array also has two elements, find the median of four elements.If the larger array has an odd number of elements, then the median will be one of the following 3 elements Middle element of larger arrayMax of the second element of smaller array and element just before the middle, i.e M/2-1th element in a bigger arrayMin of the first element of smaller array and element just after the middle in the bigger array, i.e M/2 + 1th element in the bigger arrayIf the larger array has even number of elements, then the median will be one of the following 4 elements The middle two elements of the larger arrayMax of the first element of smaller array and element just before the first middle element in the bigger array, i.e M/2 – 2nd elementMin of the second element of smaller array and element just after the second middle in the bigger array, M/2 + 1th element
If the larger array also has two elements, find the median of four elements.If the larger array has an odd number of elements, then the median will be one of the following 3 elements Middle element of larger arrayMax of the second element of smaller array and element just before the middle, i.e M/2-1th element in a bigger arrayMin of the first element of smaller array and element just after the middle in the bigger array, i.e M/2 + 1th element in the bigger arrayIf the larger array has even number of elements, then the median will be one of the following 4 elements The middle two elements of the larger arrayMax of the first element of smaller array and element just before the first middle element in the bigger array, i.e M/2 – 2nd elementMin of the second element of smaller array and element just after the second middle in the bigger array, M/2 + 1th element
If the larger array also has two elements, find the median of four elements.
If the larger array has an odd number of elements, then the median will be one of the following 3 elements Middle element of larger arrayMax of the second element of smaller array and element just before the middle, i.e M/2-1th element in a bigger arrayMin of the first element of smaller array and element just after the middle in the bigger array, i.e M/2 + 1th element in the bigger array
Middle element of larger arrayMax of the second element of smaller array and element just before the middle, i.e M/2-1th element in a bigger arrayMin of the first element of smaller array and element just after the middle in the bigger array, i.e M/2 + 1th element in the bigger array
Middle element of larger array
Max of the second element of smaller array and element just before the middle, i.e M/2-1th element in a bigger array
Min of the first element of smaller array and element just after the middle in the bigger array, i.e M/2 + 1th element in the bigger array
If the larger array has even number of elements, then the median will be one of the following 4 elements The middle two elements of the larger arrayMax of the first element of smaller array and element just before the first middle element in the bigger array, i.e M/2 – 2nd elementMin of the second element of smaller array and element just after the second middle in the bigger array, M/2 + 1th element
The middle two elements of the larger arrayMax of the first element of smaller array and element just before the first middle element in the bigger array, i.e M/2 – 2nd elementMin of the second element of smaller array and element just after the second middle in the bigger array, M/2 + 1th element
The middle two elements of the larger array
Max of the first element of smaller array and element just before the first middle element in the bigger array, i.e M/2 – 2nd element
Min of the second element of smaller array and element just after the second middle in the bigger array, M/2 + 1th element
 
How can one half of each array be discarded?
 
Let’s take an example to understand thisInput :arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},brr[] = { 11, 12, 13, 14, 15, 16, 17, 18, 19 }Dry Run of the code:Recursive call 1:smaller array[] = 1 2 3 4 5 6 7 8 9 10, mid = 5larger array[] = 11 12 13 14 15 16 17 18 19 , mid = 15
5 < 15Discard first half of the first array and second half of the second array
Recursive call 2:smaller array[] = 11 12 13 14 15, mid = 13larger array[] = 5 6 7 8 9 10, mid = 7
7 < 13Discard first half of the second array and second half of the first array
Recursive call 3:smaller array[] = 11 12 13 , mid = 12larger array[] = 7 8 9 10 , mid = 8
8 < 12Discard first half of the second array and second half of the first array
Recursive call 4:smaller array[] = 11 12larger array[] = 8 9 10
Size of the smaller array is 2 and the size of the larger array is oddso, the median will be the median of max( 11, 8), 9, min( 10, 12)that is 9, 10, 11, so the median is 10.
Output:10.000000
 
Algorithm: 
 
Create a recursive function that takes two arrays and the sizes of both the arrays.Take care of the base cases for the size of arrays less than 2. (previously discussed in Approach).Note: The first array is always the smaller array.Find the middle elements of both the arrays. i.e element at (n – 1)/2 and (m – 1)/2 of first and second array respectively. Compare both the elements.If the middle element of the smaller array is less than the middle element of the larger array then the first half of the smaller array is bound to lie strictly in the first half of the merged array. It can also be stated that there is an element in the first half of the larger array and the second half of the smaller array which is the median. So, reduce the search space to the first half of the larger array and the second half of the smaller array.Similarly, If the middle element of the smaller array is greater than the middle element of the larger array then reduce the search space to the first half of the smaller array and second half of the larger array.
Create a recursive function that takes two arrays and the sizes of both the arrays.
Take care of the base cases for the size of arrays less than 2. (previously discussed in Approach).Note: The first array is always the smaller array.
Find the middle elements of both the arrays. i.e element at (n – 1)/2 and (m – 1)/2 of first and second array respectively. Compare both the elements.
If the middle element of the smaller array is less than the middle element of the larger array then the first half of the smaller array is bound to lie strictly in the first half of the merged array. It can also be stated that there is an element in the first half of the larger array and the second half of the smaller array which is the median. So, reduce the search space to the first half of the larger array and the second half of the smaller array.
Similarly, If the middle element of the smaller array is greater than the middle element of the larger array then reduce the search space to the first half of the smaller array and second half of the larger array.
 
Implementation: 
 
C++
Java
Python3
C#
PHP
Javascript
// 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 integersfloat MO2(int a, int b){ return ( a + b ) / 2.0; } // A utility function to find median of three integersfloat 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 a median of four integersfloat 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 arrayfloat 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 emptyfloat 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 findMedianUtilfloat 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 functionsint 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;}
// A Java program to find median of two sorted arrays of// unequal sizesimport java.util.*; class GFG {     // A utility function to find median of two integers    static float MO2(int a, int b) {        return (float) ((a + b) / 2.0);    }     // A utility function to find median of three integers    static float MO3(int a, int b, int c) {        return a + b + c - Math.max(a, Math.max(b, c)) -          Math.min(a, Math.min(b, c));    }     // A utility function to find a median of four integers    static float MO4(int a, int b, int c, int d) {        int Max = Math.max(a, Math.max(b, Math.max(c, d)));        int Min = Math.min(a, Math.min(b, Math.min(c, d)));        return (float) ((a + b + c + d - Max - Min) / 2.0);    }     // Utility function to find median of single array    static float medianSingle(int arr[], int n) {        if (n == 0)            return -1;        if (n % 2 == 0)            return (float) ((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    static 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 % 2 == 1)                return MO2(B[M / 2], (int) 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 % 2 == 1)                return MO3(B[M / 2], Math.max(A[0], B[M / 2 - 1]),                           Math.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],                       Math.max(A[0], B[M / 2 - 2]),                       Math.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(Arrays.copyOfRange(A, idxA, A.length),                                  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,               Arrays.copyOfRange(B, idxB, B.length), M - idxA);    }     // A wrapper function around findMedianUtil(). This function    // makes sure that smaller array is passed as first argument    // to findMedianUtil    static 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    public static void main(String[] args)    {        int A[] = { 900 };        int B[] = { 5, 8, 10, 20 };         int N = A.length;        int M = B.length;         System.out.printf("%f", findMedian(A, N, B, M));    }} // This code is contributed by Princi Singh.
# A Python3 program to find median of two sorted arrays of# unequal sizes # A utility function to find median of two integersdef MO2(a, b) :    return ( a + b ) / 2 # A utility function to find median of three integersdef MO3(a, b, c) :     return a + b + c - max(a, max(b, c)) - min(a, min(b, c)) # A utility function to find a median of four integersdef 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 # Utility function to find median of single arraydef 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 emptydef 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 = {9}, B[] = {5, 8, 10, 20, 30} and        # A[] = {1}, B[] = {5, 8, 10, 20, 30}        if (M & 1 != 0) :            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    elif (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 != 0) :            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 findMedianUtildef findMedian(A, N, B, M) :     if (N > M) :        return findMedianUtil( B, M, A, N );    return findMedianUtil( A, N, B, M ) # Driver codeA = [900]B = [5, 8, 10, 20] N = len(A)M = len(B) print(findMedian(A, N, B, M )) # This code is contributed by divyesh072019
// A C# program to find median of two sorted arrays of// unequal sizesusing System;class GFG{         // A utility function to find median of two integers    static float MO2(int a, int b)    {        return (float) ((a + b) / 2.0);    }      // A utility function to find median of three integers    static float MO3(int a, int b, int c)    {        return a + b + c - Math.Max(a, Math.Max(b, c)) -          Math.Min(a, Math.Min(b, c));    }      // A utility function to find a median of four integers    static float MO4(int a, int b, int c, int d)    {        int Max = Math.Max(a, Math.Max(b, Math.Max(c, d)));        int Min = Math.Min(a, Math.Min(b, Math.Min(c, d)));        return (float) ((a + b + c + d - Max - Min) / 2.0);    }      // Utility function to find median of single array    static float medianSingle(int[] arr, int n)    {        if (n == 0)            return -1;        if (n % 2 == 0)            return (float) ((double) (arr[n / 2] +                                      arr[n / 2 - 1]) / 2);        return arr[n / 2];    }         static int[] copyOfRange (int[] src, int start, int end)    {        int len = end - start;        int[] dest = new int[len];        Array.Copy(src, start, dest, 0, len);        return dest;    }     // This function assumes that N is smaller than or equal to M    // This function returns -1 if both arrays are empty    static 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 % 2 == 1)                return MO2(B[M / 2], (int) 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 % 2 == 1)                return MO3(B[M / 2], Math.Max(A[0], B[M / 2 - 1]),                           Math.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],                       Math.Max(A[0], B[M / 2 - 2]),                       Math.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(copyOfRange(A, idxA, A.Length),                                  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,                              copyOfRange(B, idxB, B.Length), M - idxA);    }      // A wrapper function around findMedianUtil(). This function    // makes sure that smaller array is passed as first argument    // to findMedianUtil    static 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 code  static void Main()  {        int[] A = { 900 };        int[] B = { 5, 8, 10, 20 };          int N = A.Length;        int M = B.Length;          Console.WriteLine(findMedian(A, N, B, M));  }} // This code is contributed by divyeshrabadiya07
<?php// A PHP program to find median// of two sorted arrays of// unequal sizes // A utility function to// find median of two integersfunction MO2($a, $b){    return ($a + $b) / 2.0;} // A utility function to// find median of three integersfunction 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 integersfunction 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 arrayfunction 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 emptyfunction 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 findMedianUtilfunction 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?>
<script>// A Javascript program to find median of two sorted arrays of// unequal sizes // A utility function to find median of two integersfunction MO2(a,b){    return ((a + b) / 2.0);} // A utility function to find median of three integersfunction MO3(a, b, c){    return a + b + c - Math.max(a, Math.max(b, c)) -          Math.min(a, Math.min(b, c));} // A utility function to find a median of four integersfunction MO4(a, b, c, d){    let Max = Math.max(a, Math.max(b, Math.max(c, d)));    let Min = Math.min(a, Math.min(b, Math.min(c, d)));    return ((a + b + c + d - Max - Min) / 2.0);} // Utility function to find median of single arrayfunction 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 emptyfunction 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 = {9}, B[] = {5, 8, 10, 20, 30} and            // A[] = {1}, B[] = {5, 8, 10, 20, 30}            if (M % 2 == 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 % 2 == 1)                return MO3(B[M / 2], Math.max(A[0], B[M / 2 - 1]),                           Math.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],                       Math.max(A[0], B[M / 2 - 2]),                       Math.min(A[1], B[M / 2 + 1]));        }          let idxA = (N - 1) / 2;        let 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.slice(idxA, A.length),                                  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.slice( idxB, B.length), M - idxA);} // A wrapper function around findMedianUtil(). This function    // makes sure that smaller array is passed as first argument    // to findMedianUtilfunction findMedian(A,N,B,M){    if (N > M)            return findMedianUtil(B, M, A, N);          return findMedianUtil(A, N, B, M);} // Driver program to test above functionslet A = [ 900];let B = [5, 8, 10, 20];let N = A.length;let M = B.length;document.write(findMedian(A, N, B, M)); // This code is contributed by avanitrachhadiya2155</script>
10.000000
Complexity Analysis: 
Time Complexity: O(min(log m, log n)). In each step one half of each array is discarded. So the algorithm takes O(min(log m, log n)) time to reach the median value.
Space Complexity: O(1). No extra space is required.
Solution 3 : Simple Mathematical Approach 
Approach: The given two arrays are sorted, so we need to merge them into a third array using the method System.arraycopy(src, srcPos, dest, destPos, length) and then sort the third array using Arrays.sort(array) method.
1. Case 1: If the length of the third array is odd, then the median is at (length)/2 th index in the array obtained after merging both the arrays.
2. Case 2: If the length of the third array is even, then the median will be the average of elements at index ((length)/2 ) and ((length)/2 – 1) in the array obtained after merging both the arrays.
1. Merge the two given arrays into one array.
2. Then sort the third(merged) array
3. If the length of the third array is even then :
    divide the length of array by 2
    return arr[value]  + arr[value - 1] / 2
    
4. If the length of the third array is odd then :
    divide the length of array by 2
    round that value 
    return the arr[value] 
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; int Solution(int arr[], int n){      // If length of array is even     if (n % 2 == 0)     {       int z = n / 2;       int e = arr[z];       int q = arr[z - 1];       int ans = (e + q) / 2;       return ans;     }         // If length if array is odd    else     {       int z = round(n / 2);       return arr[z];     }}  // Driver Codeint main() {            // TODO Auto-generated method stub        int arr1[] = { -5, 3, 6, 12, 15 };        int arr2[] = { -12, -10, -6, -3, 4, 10 };         int i =  sizeof(arr1) / sizeof(arr1[0]);        int j =  sizeof(arr2) / sizeof(arr2[0]);         int arr3[i+j];        int l =  i+j;        // Merge two array into one array        for(int k=0;k<i;k++)        {            arr3[k]=arr1[k];        }                  int a=0;         for(int k=i;k<l;k++)        {            arr3[k]=arr2[a++];        }         // Sort the merged array        sort(arr3,arr3+l);         // calling the method        cout<<"Median = " << Solution(arr3, l);} // This code is contributed by SoumikMondal
// Java program for the above approachimport java.io.*;import java.util.Arrays; public class GFG {    public static int Solution(int[] arr)    {        int n = arr.length;               // If length of array is even        if (n % 2 == 0)        {            int z = n / 2;            int e = arr[z];            int q = arr[z - 1];             int ans = (e + q) / 2;            return ans;        }               // If length if array is odd        else        {            int z = Math.round(n / 2);            return arr[z];        }    }     // Driver Code    public static void main(String[] args)    {                 // TODO Auto-generated method stub        int[] arr1 = { -5, 3, 6, 12, 15 };        int[] arr2 = { -12, -10, -6, -3, 4, 10 };         int i = arr1.length;        int j = arr2.length;         int[] arr3 = new int[i + j];         // Merge two array into one array        System.arraycopy(arr1, 0, arr3, 0, i);        System.arraycopy(arr2, 0, arr3, i, j);         // Sort the merged array        Arrays.sort(arr3);         // calling the method        System.out.print("Median = " + Solution(arr3));    }}// This code is contributed by Manas Tole
# Python3 program for the above approachdef Solution(arr):     n = len(arr)     # If length of array is even    if n % 2 == 0:        z = n // 2        e = arr[z]        q = arr[z - 1]        ans = (e + q) / 2        return ans             # If length of array is odd    else:        z = n // 2        ans = arr[z]        return ans # Driver codeif __name__ == "__main__":         arr1 = [ -5, 3, 6, 12, 15 ]    arr2 = [ -12, -10, -6, -3, 4, 10 ]     # Concatenating the two arrays    arr3 = arr1 + arr2     # Sorting the resultant array    arr3.sort()     print("Median = ", Solution(arr3))     # This code is contributed by kush11
// C# program for the above approachusing System;using System.Collections.Generic; public class GFG {    public static int Solution(int[] arr)    {        int n = arr.Length;               // If length of array is even        if (n % 2 == 0)        {            int z = n / 2;            int e = arr[z];            int q = arr[z - 1];             int ans = (e + q) / 2;            return ans;        }               // If length if array is odd        else        {            int z = n / 2;            return arr[z];        }    }     // Driver Code    static public void Main (){                 // TODO Auto-generated method stub        int[] arr1 = { -5, 3, 6, 12, 15 };        int[] arr2 = { -12, -10, -6, -3, 4, 10 };                 // Merge two array into one array        var myList = new List<int>();        myList.AddRange(arr1);        myList.AddRange(arr2);        int[] arr3 = myList.ToArray();         // Sort the merged array        Array.Sort(arr3);                 // calling the method        Console.Write("Median = " + Solution(arr3));    }} // This code is contributed by Shubhamsingh10
<script>// Javascript program for the above approach function Solution(arr, n){      // If length of array is even     if (n % 2 == 0)     {       var z = n / 2;       var e = arr[z];       var q = arr[z - 1];       var ans = (e + q) / 2;       return ans;     }         // If length if array is odd    else     {       var z = Math.floor(n / 2);       return arr[z];     }} // Driver Code  // TODO Auto-generated method stubvar arr1 = [ -5, 3, 6, 12, 15 ];var arr2 = [ -12, -10, -6, -3, 4, 10 ]; var i =  arr1.length;var j =  arr2.length; var l =  i+j;// Merge two array into one arrayconst arr3 = arr1.concat(arr2); // Sort the merged arrayarr3.sort(function(a, b) {  return a - b;}); // calling the methoddocument.write("Median = " + Solution(arr3, l)); // This code is contributed by Shubham Singh</script>
  
Median = 3
 
Complexity Analysis :
 
Time Complexity: O((n+m) Log (n+m))
Space Complexity: O(n+m). Since we are creating a new array of size n+m.
 
Solution 4 : Binary Search
 
Approach: The given two arrays are sorted, so we can utilize the ability of Binary Search to divide the array and find the median.
 
Median means the point at which the whole array is divide into two parts. Hence since the two arrays are not merged so to get the median we require merging which is costly. Hence instead of merging we will use below given algorithm to efficiently find median.
 
Algorithm:
 
1. Lets assume that there are two arrays A and B with array A having the minimum number of elements.
   If this is not the case then swap A and B to make A having small size.
2. The edge cases like one array is empty or both are empty will be handled.
3. let n be the size of A and m be the size of B.
   Now think of an idea that if we have to find the median than we have to divide the whole merged array into two parts
   namely left and right parts.
   Now since we are given the size of left part (i.e (n+m+1)/2), Now look at below given example.
   
       A-> 1,2,3,4,5     n = 5
       B-> 1,2,3,4,5,6   m = 6
   
    Here merged array will look like :- 1,1,2,2,3,3,4,4,5,5,6 and median then is 3
    
    Now we can see our left part which is underlined. We divide A and B into two parts such that the 
    sum of left part of both A and B will result in left part of merged array.
    
    A-> 1,2,3,4,5     // pointers l =0 and r = n-1 hence mid = (l+r)/2;
       B -> 1,2,3,4,5,6

    we can see that left part of A is given as n/2 and since total length of left part in merged array
    is (m+n+1)/2, so left part of B = (m+n+1)/2-n/2;
    
    Now we just have to confirm if our left and right partitions in A and B are correct or not.
    
4. Now we have 4 variables indicating four values two from array A and two from array B.
    leftA -> Rightmost element in left part of A = 2
    leftb -> Rightmost element in left part of B = 4
    rightA -> Leftmost element in right part of A = 3
    rightB -> Leftmost element in right part of B = 5
    
    Hence to confirm that partition is correct we have to check the following conditions.
    leftA<=rightB and leftB<=rightA  // This is the case when the sum of two parts of A and B results in left part of merged array
    
    if our partition not works that means we have to  find other mid point in A and then left part in B
    This is seen when
     
    leftA > rightB    //means we have to dec size of A's partition
    so do r = mid-1;
    else
        do l =mid+1;
    
    Hence repeat the above steps with new partitions till we get the answers.
5. If leftA<=rightB and leftB<=rightA
    then we get correct partition and our answer depends on the total size of merged array (i.e. m+n)
    
    If (m+n)%2==0
     ans is max(leftA,leftB)+min(rightA,rightB)/2; // max of left part is nearest to median and min of right part is nearest to medain
    else
     ans is max(leftA,leftB);
 
Hence the above algorithm can be coded as
 
C++
Java
Python3
C#
Javascript
#include <bits/stdc++.h>using namespace std; // Method to find mediandouble Median(vector<int>& A, vector<int>& B){    int n = A.size();    int m = B.size();    if (n > m)        return Median(B, A); // Swapping to make A smaller     int start = 0;    int end = n;    int realmidinmergedarray = (n + m + 1) / 2;     while (start <= end) {        int mid = (start + end) / 2;        int leftAsize = mid;        int leftBsize = realmidinmergedarray - mid;        int leftA            = (leftAsize > 0)                  ? A[leftAsize - 1]                  : INT_MIN; // checking overflow of indices        int leftB            = (leftBsize > 0) ? B[leftBsize - 1] : INT_MIN;        int rightA            = (leftAsize < n) ? A[leftAsize] : INT_MAX;        int rightB            = (leftBsize < m) ? B[leftBsize] : INT_MAX;         // if correct partition is done        if (leftA <= rightB and leftB <= rightA) {            if ((m + n) % 2 == 0)                return (max(leftA, leftB)                        + min(rightA, rightB))                       / 2.0;            return max(leftA, leftB);        }        else if (leftA > rightB) {            end = mid - 1;        }        else            start = mid + 1;    }    return 0.0;} // Driver codeint main(){    vector<int> arr1 = { -5, 3, 6, 12, 15 };    vector<int> arr2 = { -12, -10, -6, -3, 4, 10 };    cout << "Median of the two arrays are" << endl;    cout << Median(arr1, arr2);    return 0;}
public class GFG {     // Method to find median    static double Median(int[] A, int[] B)    {        int n = A.length;        int m = B.length;        if (n > m)            return Median(B, A); // Swapping to make A smaller         int start = 0;        int end = n;        int realmidinmergedarray = (n + m + 1) / 2;         while (start <= end) {            int mid = (start + end) / 2;            int leftAsize = mid;            int leftBsize = realmidinmergedarray - mid;            int leftA                    = (leftAsize > 0)                    ? A[leftAsize - 1]                    : Integer.MIN_VALUE; // checking overflow of indices            int leftB                    = (leftBsize > 0) ? B[leftBsize - 1] : Integer.MIN_VALUE;            int rightA                    = (leftAsize < n) ? A[leftAsize] : Integer.MAX_VALUE;            int rightB                    = (leftBsize < m) ? B[leftBsize] : Integer.MAX_VALUE;             // if correct partition is done            if (leftA <= rightB && leftB <= rightA) {                if ((m + n) % 2 == 0)                    return (Math.max(leftA, leftB)                            + Math.min(rightA, rightB))                            / 2.0;                return Math.max(leftA, leftB);            }        else if (leftA > rightB) {                end = mid - 1;            }            else                start = mid + 1;        }        return 0.0;    }   // Driver code    public static void main(String[] args) {        int[] arr1 = { -5, 3, 6, 12, 15 };        int[] arr2 = { -12, -10, -6, -3, 4, 10 };        System.out.println("Median of the two arrays are");        System.out.println(Median(arr1, arr2));    }} // This code is contributed by Hritik
class Solution:     # Method to find median    def Median(self, A, B):                 # Assumption both A and B cannot be empty        n = len(A)        m = len(B)        if (n > m):            return self.Median(B, A)  # Swapping to make A smaller         start = 0        end = n        realmidinmergedarray = (n + m + 1) // 2         while (start <= end):            mid = (start + end) // 2            leftAsize = mid            leftBsize = realmidinmergedarray - mid                         # checking overflow of indices            leftA = A[leftAsize - 1] if (leftAsize > 0) else float('-inf')            leftB = B[leftBsize - 1] if (leftBsize > 0) else float('-inf')            rightA = A[leftAsize] if (leftAsize < n) else float('inf')            rightB = B[leftBsize] if (leftBsize < m) else float('inf')             # if correct partition is done            if leftA <= rightB and leftB <= rightA:                if ((m + n) % 2 == 0):                    return (max(leftA, leftB) + min(rightA, rightB)) / 2.0                return max(leftA, leftB)             elif (leftA > rightB):                end = mid - 1            else:                start = mid + 1 # Driver codeans = Solution()arr1 = [-5, 3, 6, 12, 15]arr2 = [-12, -10, -6, -3, 4, 10]print("Median of the two arrays is {}".format(ans.Median(arr1, arr2))) # This code is contributed by Arpan
using System; public class GFG {   // Method to find median  static double Median(int[] A, int[] B)  {    int n = A.Length;    int m = B.Length;    if (n > m)      return Median(B, A); // Swapping to make A smaller     int start = 0;    int end = n;    int realmidinmergedarray = (n + m + 1) / 2;     while (start <= end) {      int mid = (start + end) / 2;      int leftAsize = mid;      int leftBsize = realmidinmergedarray - mid;      int leftA        = (leftAsize > 0)        ? A[leftAsize - 1]        : Int32.MinValue; // checking overflow of indices      int leftB        = (leftBsize > 0) ? B[leftBsize - 1] : Int32.MinValue;      int rightA        = (leftAsize < n) ? A[leftAsize] : Int32.MaxValue;      int rightB        = (leftBsize < m) ? B[leftBsize] : Int32.MaxValue;       // if correct partition is done      if (leftA <= rightB && leftB <= rightA) {        if ((m + n) % 2 == 0)          return (Math.Max(leftA, leftB)                  + Math.Min(rightA, rightB))          / 2.0;        return Math.Max(leftA, leftB);      }      else if (leftA > rightB) {        end = mid - 1;      }      else        start = mid + 1;    }    return 0.0;  }   // Driver code  public static void Main() {    int[] arr1 = { -5, 3, 6, 12, 15 };    int[] arr2 = { -12, -10, -6, -3, 4, 10 };    Console.WriteLine("Median of the two arrays are");    Console.WriteLine(Median(arr1, arr2));  }} // This code is contributed by Shubham Singh
<script>        // JavaScript Program to implement        // the above approach         // Method to find median        function Median(A, B) {            let n = A.length;            let m = B.length;            if (n > m)                return Median(B, A); // Swapping to make A smaller             let start = 0;            let end = n;            let realmidinmergedarray = Math.floor((n + m + 1) / 2);             while (start <= end) {                let mid = Math.floor((start + end) / 2);                let leftAsize = mid;                let leftBsize = realmidinmergedarray - mid;                let leftA                    = (leftAsize > 0)                        ? A[leftAsize - 1]                        : Number.MIN_VALUE; // checking overflow of indices                let leftB                    = (leftBsize > 0) ? B[leftBsize - 1] : INT_MIN;                let rightA                    = (leftAsize < n) ? A[leftAsize] : INT_MAX;                let rightB                    = (leftBsize < m) ? B[leftBsize] : INT_MAX;                 // if correct partition is done                if (leftA <= rightB && leftB <= rightA) {                    if ((m + n) % 2 == 0)                        return Math.floor((Math.max(leftA, leftB)                            + Math.min(rightA, rightB))                            / 2.0);                    return Math.max(leftA, leftB);                }                else if (leftA > rightB) {                    end = mid - 1;                }                else                    start = mid + 1;            }            return 0.0;        }         // Driver code        let arr1 = [-5, 3, 6, 12, 15];        let arr2 = [-12, -10, -6, -3, 4, 10];        document.write("Median of the two arrays are" + "<br>");        document.write(Median(arr1, arr2)) // This code is contributed by Potta Lokesh    </script>
  
Median of the two arrays are
3
 
Time Complexity: O(min(log m, log n)) : Since binary search is being applied on the smaller of the 2 arraysAuxiliary Space: O(1)
 
ukasp
pratil
Raj Bansal
AkshAyMore2
rathbhupendra
ankush_953
andrew1234
Akanksha_Rai
nsit_changeable
ysinghal555
princi singh
divyeshrabadiya07
divyesh072019
manastole01
saipraveenm99
mukesh07
SoumikMondal
vilajaxmyai
kush11
avanitrachhadiya2155
SHUBHAMSINGH10
harshkumarchoudhary144
hritikrommie
ruhelaa48
namanbansal4
arpansheetal
lokeshpotta20
rajesh999
anuragncp
architgwl2000
Binary Search
median-finding
statistical-algorithms
Divide and Conquer
Searching
Searching
Divide and Conquer
Binary Search
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Program for Tower of Hanoi
Divide and Conquer Algorithm | Introduction
Write a program to calculate pow(x,n)
Count number of occurrences (or frequency) in a sorted array
Quick Sort vs Merge Sort
Linear Search
Search an element in a sorted and rotated array
Find the Missing Number
K'th Smallest/Largest Element in Unsorted Array | Set 1
Program to find largest element in an array