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:
def findMedianSortedArrays(self, nums1, nums2):
"""
:type nums1: List[int]
:type nums2: List[int]
:rtype: float
"""
list_ = []
i = j = 0
len_ = len(nums1)+len(nums2)
while i<len(nums1) and j<len(nums2):
if nums1[i] <= nums2[j]:
list_.append(nums1[i])
i +=1
else:
list_.append(nums2[j])
j +=1
if i<len(nums1):
list_ += nums1[i:len(nums1)]
if j<len(nums2):
list_ += nums2[j:len(nums2)]
if len_ % 2 == 0:
return (list_[len_//2 - 1] + list_[len_//2]) / 2
else:
return list_[(len_-1)//2]

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.