Given two sorted arrays `nums1`

and `nums2`

of size `m`

and `n`

respectively, return **the median** of the two sorted arrays.

The overall run time complexity should be `O(log (m+n))`

.

**Example 1:**

Input:nums1 = [1,3], nums2 = [2]Output:2.00000Explanation:merged array = [1,2,3] and median is 2.

**Example 2:**

Input:nums1 = [1,2], nums2 = [3,4]Output:2.50000Explanation:merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.

**Example 3:**

Input:nums1 = [0,0], nums2 = [0,0]Output:0.00000

**Example 4:**

Input:nums1 = [], nums2 = [1]Output:1.00000

**Example 5:**

Input:nums1 = [2], nums2 = []Output:2.00000

**Constraints:**

`nums1.length == m`

`nums2.length == n`

`0 <= m <= 1000`

`0 <= n <= 1000`

`1 <= m + n <= 2000`

`-10`

^{6}<= nums1[i], nums2[i] <= 10^{6}

class Solution {
public:
int kth(int a[], int m, int b[], int n, int k) {
if (m < n) return kth(b,n,a,m,k);
if (n==0) return a[k-1];
if (k==1) return min(a[0],b[0]);
int j = min(n,k/2);
int i = k-j;
if (a[i-1] > b[j-1]) return kth(a,i,b+j,n-j,k-j);
return kth(a+i,m-i,b,j,k-i);
}
double findMedianSortedArrays(int a[], int m, int b[], int n) {
int k = (m+n)/2;
int m1 = kth(a,m,b,n,k+1);
if ((m+n)%2==0) {
int m2 = kth(a,m,b,n,k);
return ((double)m1+m2)/2.0;
}
return m1;
}
};

The main gist of this solution is to use Binary search on the shorter size of Array and create partitioning in which both partitions will be having the same number of elements where all elements in the left partition is smaller than all the elements on the right side of the partition.

Time Complexity: O(log(min(m,n)) //Where m and n are the sizes of both the arrays.

Space Complexity: O(1) // We are not using any extra space.