# Median of two sorted arrays of different sizes

• Difficulty Level : Expert
• Last Updated : 29 Jul, 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.

Approach 1 (Simple Mathematical Approach)
The given two arrays are sorted, so we need to merge them into a third array.

• Case 1: If the length of the third array is odd, then the median is at (length)/2th index in the array obtained after merging both the arrays.
• 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.

Illustration:

arr1[] = { -5, 3, 6, 12, 15 } , arr2[] = { -12, -10, -6, -3, 4, 10 }

• After merging them in a third array : arr3[] = { -5, 3, 6, 12, 15, -12, -10, -6, -3, 4, 10}
• Sort arr3[ ] = { -12, -10, -6, -5, -3, 3, 4, 6, 10, 12, 15 }
• As the length of arr3 is odd, so the median is 3

Algorithm:

• Merge the two given arrays into one array.
• Then sort the third(merged) array
• If the length of the third array is even then : divide the length of array by 2 return arr[value]  + arr[value – 1] / 2
• If the length of the third array is odd then: divide the length of the array by 2 round that value returns the arr[value]

Implementation:

## C++

 `// C++ program for the above approach` `#include ` `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 Code` `int` `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);` `        ``int` `j =  ``sizeof``(arr2) / ``sizeof``(arr2);`   `        ``int` `arr3[i+j];` `        ``int` `l =  i+j;` `        ``// Merge two array into one array` `        ``for``(``int` `k=0;k

## Java

 `// Java program for the above approach` `import` `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

 `# Python3 program for the above approach` `def` `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 code` `if` `__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#

 `// C# program for the above approach` `using` `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`

## Javascript

 ``

Output

`Median = 3`

Complexity Analysis :
Time Complexity: O((n+m) Log (n+m))
Auxiliary Space: O(n+m). Since we are creating a new array of size n+m.

Approach 2:
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 the average of elements at index ((m+n)/2 – 1) and (m+n)/2 in the array obtained after merging both the arrays

Illustration:

Given two array ar1[ ]= { 900 } and ar2[ ] = { 5, 8, 10, 20 } , n => Size of ar1 = 1 and m => Size of ar2 = 4

• Loop will run from 0 till 2.
• First iteration : { 900 }  { 5, 8, 10, 20 } , m1 = 5
• Second iteration : { 900 }  { 5, 8, 10, 20 }, m1 = 8
• Third iteration : { 900 }  { 5, 8, 10, 20 }, m1 = 10
• As size of ar1 + ar2 = odd , hence we return m1 = 10 as the median

Algorithm:

1. 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.
2. 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).
3. To merge both arrays, keep two indices i and j initially assigned to 0. Compare the ith index of 1st array and jth index of the second, increase the index of the smallest element and increase the count.
4. Store (m+n)/2 and (m+n)/2-1 in two variables.
5. Check if the count reached (m+n) / 2. If (m+n) is odd return m1, If even return (m1+m2)/2. Implementation:

## C++

 `// A Simple Merge based O(n) solution to find ` `// median of two sorted arrays ` `#include ` `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

## Python

 `# 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`  `    ``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

## Java

 `// A Simple Merge based O(n) solution` `// to find median of two sorted arrays` `class` `GFG{` `    `  `// Function to calculate median` `static` `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 ar2[j]) ? ` `                      ``ar2[j++] : ar1[i++];` `            ``} ` `            ``else` `if` `(i < n)` `            ``{` `                ``m1 = ar1[i++];` `            ``}` `            `  `            ``// for case when j

## Python

 `# 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`  `    ``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

## C#

 `// A Simple Merge based O(n) solution` `// to find median of two sorted arrays` `using` `System;`   `class` `GFG{` `    `  `// Function to calculate median` `static` `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 ar2[j]) ? ` `                      ``ar2[j++] : ar1[i++];` `            ``} ` `            ``else` `if` `(i < n)` `            ``{` `                ``m1 = ar1[i++];` `            ``}` `            `  `            ``// for case when j

## Javascript

 ``

Output

`10`

Complexity Analysis:
Time Complexity: O(m + n). To merge both the arrays O(m+n) time is needed.
Auxiliary Space: O(1). No extra space is required.

Approach 3 (Efficient):
The idea is simple, calculate the median of both the arrays and discard one-half of each array. This approach takes into consideration the size of the arrays. The smaller-sized array is considered the first array in the parameter.
There are some basic corner cases:

• If the size of the smaller array is 0. Return the median of a larger array.
• if the size of the 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 the 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 the 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
• The middle element of the 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 an even number of elements, then the median will be one of the following 4 elements
• 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

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.
• If the middle element of the smaller sized 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.

Illustration :

Let’s take an example to understand this
Input :arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
brr[] = { 11, 12, 13, 14, 15, 16, 17, 18, 19 }

Recursive call 1:
smaller array[] = 1 2 3 4 5 6 7 8 9 10, mid = 5
larger array[] = 11 12 13 14 15 16 17 18 19 , mid = 15

5 < 15
Discard first half of the first array and second half of the second array

Recursive call 2:
smaller array[] = 11 12 13 14 15, mid = 13
larger array[] = 5 6 7 8 9 10, mid = 7

7 < 13
Discard first half of the second array and second half of the first array

Recursive call 3:
smaller array[] = 11 12 13 , mid = 12
larger array[] = 7 8 9 10 , mid = 8

8 < 12
Discard first half of the second array and second half of the first array

Recursive call 4:
smaller array[] = 11 12
larger array[] = 8 9 10

Size of the smaller array is 2 and the size of the larger array is odd
so, 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:

1. Create a recursive function that takes two arrays and the sizes of both arrays.
2. 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.
3. 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.
4. 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.
5. 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 the second half of the larger array.

Implementation:

## C++

 `// A C++ program to find median of two sorted arrays of` `// unequal sizes` `#include ` `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 a 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, B);`   `        ``// 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, 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 );` `    ``}`   `    ``// 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, A, B, B);`   `        ``// 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, B[M/2 - 1]),` `                         ``min(A, 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, B[M/2 - 2] ),` `                     ``min( A, 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);` `    ``int` `M = ``sizeof``(B) / ``sizeof``(B);`   `    ``printf``(``"%f"``, findMedian( A, N, B, M ) );` `    ``return` `0;` `}`

## Java

 `// A Java program to find median of two sorted arrays of` `// unequal sizes` `import` `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.`

## Python3

 `# A Python3 program to find median of two sorted arrays of` `# unequal sizes`   `# A utility function to find median of two integers` `def` `MO2(a, b) :` `    ``return` `( a ``+` `b ) ``/` `2`   `# A utility function to find median of three integers` `def` `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 integers` `def` `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 array` `def` `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` `def` `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 findMedianUtil` `def` `findMedian(A, N, B, M) :`   `    ``if` `(N > M) :` `        ``return` `findMedianUtil( B, M, A, N );` `    ``return` `findMedianUtil( A, N, B, M )`   `# Driver code` `A ``=` `[``900``]` `B ``=` `[``5``, ``8``, ``10``, ``20``]`   `N ``=` `len``(A)` `M ``=` `len``(B)`   `print``(findMedian(A, N, B, M ))`   `# This code is contributed by divyesh072019`

## C#

 `// A C# program to find median of two sorted arrays of` `// unequal sizes` `using` `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, B);` ` `  `            ``// 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, ` `                            ``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);` `        ``}` ` `  `        ``// 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, A, B, B);` ` `  `            ``// 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, B[M / 2 - 1]),` `                           ``Math.Min(A, 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, B[M / 2 - 2]), ` `                       ``Math.Min(A, 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

 ` \$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` `?>`

## Javascript

 ``

Output

`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.
Auxiliary Space: O(1). No extra space is required.

Approach 4 (Binary Search):
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 divided 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 modified binary search algorithm to efficiently find the median.

Algorithm:
Let’s 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 have a small size. Let n be the size of A and m be the size of B. If we would have merged the two arrays, the median is the point that will divide the sorted merged array into two equal parts. So the actual median point in the merged array would have been (m+n+1)/2;

• We divide A and B into two parts. We will find the mid value and divide the first array A into two parts and simlutatanously choose only those elements from left of B array such that the sum of the count of elements in the left part of both A and B will result in the left part of the merged array.
•  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.
• leftb -> Rightmost element in left part of B
• rightA -> Leftmost element in right part of A
• rightB -> Leftmost element in right part of B
• Hence to confirm that the partition was correct we have to check if leftA<=rightB and leftB<=rightA. This is the case when the sum of two parts of A and B results in the left part of the merged array. If the condition fails we have to find another midpoint in A and then left part in B. If we find leftA > rightB. means we have to decrease the size of A’s partition and shift to lesser value in A. So we update the right pointer of to mid-1 else we will increase the left pointer to mid+1. Hence repeat the above steps with new partitions till we get the answers.
• If leftA<=rightB and leftB<=rightA, then we get the correct partition and our answer depends on the total size of the merged array (i.e. m+n). If (m+n) is even we take max(leftA,leftB) and min(rightA,rightB), add them and divide by 2 to get our answer, else we will just return the maximum of leftA and leftB.

Illustration:

A[ ] = { -5, 3, 6, 12, 15 }, n = 5  &  B[ ] = { -12, -10, -6, -3, 4, 10} , m = 6

• realmidinmergedarray = 6.
• start = 0 and end = 5 => mid = 2
• leftAsize = 2 and leftBsize = 4
• leftA = 3
• leftB = -3
• rightA = 6
• rightB = 4
•  A[ ] = { -5, 3, 6, 12, 15 } &  B[ ] = { -12, -10, -6, -3, 4, 10}
• As leftA <= rightB and leftB <= rightA, so the condition holds and 3 is returned as the median

Hence the above algorithm can be coded as :

## C++

 `#include ` `using` `namespace` `std;`   `// Method to find median` `double` `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 code` `int` `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;` `}`

## Java

 `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`

## Python3

 `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 code` `ans ``=` `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`

## C#

 `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`

## Javascript

 ``

Output

```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 arrays
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :