LeetCode Problem 4: Median of Two Sorted Arrays

Problem

There are two sorted arrays nums1 and nums2 of size m and n respectively.

Find the median of the two sorted arrays. The overall run time complexity should be $O(log(m+n))$.

You may assume nums1 and nums2 cannot be both empty.

Example 1:

nums1 = [1, 3]
nums2 = [2]
The median is 2.0

Example 2:

nums1 = [1, 2]
nums2 = [3, 4]
The median is (2 + 3) / 2 = 2.5

Solution

Approach: Recursive Approach

Algorithm

To solve this problem, we need to understand “What is the use of the median”. In statistics, the median is used for:

• Dividing a set into two equal length subsets, that one subset is always greater than the other.

If we understand the use of median for dividing, we are very close to the answer.

First, let’s cut $A$ into two parts at a random position $i$:

leftA	rightA
A[0], A[1], …, A[i-1]	A[i], A[i+1], …, A[m-1]

Since $A$ has $m$ elements, so there are $m+1$ kinds of cutting ($i=0-m$).

And we know:

• $len(leftA)=i$, $len(rightA)=m-1$.
• Note: When $i=0$, $leftA$ is empty, and when $i=m$, $rightA$ is empty.

With the same way, cut $B$ into two parts at a random position $j$:

leftB	rightB
B[0], B[1], …, B[j-1]	B[j], B[j+1], …, B[n-1]

Put $leftA$ and $leftB$ into one set, and put $rightA$ and $rightB$ into another set. Let’s name them $leftPart$ and $rightPart$:

leftPart	rightPart
A[0], A[1], …, A[i-1]	A[i], A[i+1], …, A[m-1]
B[0], B[1], …, B[j-1]	B[j], B[j+1], …, B[n-1]

If we can ensure:

• $len(leftPart)=len(rightPart)$
• $max(leftPart)\le min(rightPart)$

then we divide all the elements in {$A$, $B$} into two parts with equal length, and one part is always greater than the other. Then

$median=\frac{max(leftPart)+min(rightPart)}{2}$

To ensure these two conditions, we just need to ensure:

• $i+j=m-i+n-j$ (or: $m-i+n-j+1$)

If $n\ge m$, we just need to set: $i=0-m$, $j=\frac{m+n+1}{2}-i$

• $B[j-1]\le A[i]$ and $A[i-1]\le B[j]$

PS.1 For simplicity, we presume $A[i-1]$, $B[j-1]$, $A[i]$, $B[j]$ are always valid even if $i=0$, $i=m$, $j=0$ or $j=n$. I will talk about how to deal with these edge values at last.

PS.2 Why $n\ge m$? Because we have to make sure $j$ is non-negative since $0\le i\le m$ and $j=\frac{m+n+1}{2}-i$. If $n<m$, then $j$ may be negative, which will lead to wrong result.

So, all we need to do is:

• Searching $i$ in [0, $m$], to find an object $i$ such that:
  $B[j-1]\le A[i]$ and $A[i-1]\le B[j]$, where $j=\frac{m+n+1}{2}-i$

And we can do a binary search following steps described below:

1. Set iMin = 0, iMax = $m$, then start searching in [iMin, iMax]

2. Set $i=\frac{iMin+iMax}{2}$, $j=\frac{m+n+1}{2}-i$

3. Now we have $len(leftPart)=len(rightPart)$. And there are only 3 situations that we may encounter:

• $B[j-1]\le A[i]$ and $A[i-1]\le B[j]$
  Means we have found the object $i$, so stop searching.
• $B[j-1]>A[i]$
  Means $A[i]$ is too small. We must adjust $i$ to get $B[j-1]\le A[i]$.
  Can we increase $i$?
  Yes. Because when $i$ is increased, $j$ will be decreased.
  So $B[j-1]$ is decreased and $A[i]$ is increased, and $B[j-1]\le A[i]$ may be satified.
  Can we decrease $i$?
  No! Because when $i$ is decreased, $j$ will be increased.
  So $B[j-1]$ is increased and $A[i]$ is decreased, and $B[j-1]\le A[i]$ will never be satisfied.
  So, set iMin = $i$ + 1, and go to step 2.
• $A[i-1]>B[j]$:
  Means $A[i-1]$ is too big. And we must decrease $i$ to get $A[i-1]\le B[j]$.
  That is, we must adjust the searching range to [iMin, $i$ - 1].
  So, set iMax = $i$ - 1, and go to step 2.

When the object $i$ is found, the median is:

• $max(A[i-1],B[j-1])$, when $m+n$ is odd.
• $\frac{max(A[i-1],B[j-1])+min(A[i],B[j])}{2}$, when $m+n$ is even.

Now let’s consider the edge values $i=0$, $i=m$, $j=0$, $j=n$ where $A[i-1]$, $B[j-1]$, $A[i]$, $B[j]$ may not exist. Actually it is easier than you think.

What we need to do is ensuring that $max(leftPart)\le min(rightPart)$. So, if $i$ and $j$ are not edge values (means $A[i-1]$, $B[j-1]$, $A[i]$, $B[j]$ all exist), then we must check both $B[j-1]\le A[i]$ and $A[i-1]\le B[j]$. But if some of $A[i - 1], $B[j-1]$, $A[i]$, $B[j]$ don’t exist, then we need to check one (or both) of these two conditions. For example, if $i=0$, then $A[i-1]$ doesn’t exist, then we don’t need to check $A[i-1]\le B[j]$. So, what we need to do is:

• Searching $i$ in [0, $m$] to find an object $i$ such that:
  ($j=0$ or $i=m$ or $B[j-1]\le A[i]$) and
  ($i=0$ or $j=n$ or $A[i-1]\le B[j]$), where $j=\frac{m+n+1}{2}-i$

And in a searching loop, we will encounter only three situations:

• ($j=0$ or $i=m$ or $B[j-1]\le A[i]$) and
  ($i=0$ or $j=n$ or $A[i-1]\le B[j]$)
  Means $i$ is perfect, we can stop searching.

• $j>0$ and $i<m$ and $B[j-1]>A[i]$
  Means $i$ is too small, we must increase it.

• $i>0$ and $j<n$ and $A[i-1]>B[j]$
  Means $i$ is too big, we must decrease it.

Code: C++

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size();
        int n = nums2.size();
        if (m > n)
        {
            vector<int> temp = nums1;
            nums1 = nums2;
            nums2 = temp;
            int tmp = m;
            m = n;
            n = tmp;
        }
        int iMin = 0;
        int iMax = m;
        int halfLen = (m + n + 1) / 2;
        while (iMin <= iMax)
        {
            int i = (iMin + iMax) / 2;
            int j = halfLen - i;
            if (i < iMax && nums2[j - 1] > nums1[i])
            {
                iMin = i + 1;
            }
            else if (i > iMin && nums1[i - 1] > nums2[j])
            {
                iMax = i - 1;
            }
            else
            {
                int maxLeft = 0;
                if (i == 0)
                {
                    maxLeft = nums2[j - 1];
                }
                else if (j == 0)
                {
                    maxLeft = nums1[i - 1];
                }
                else
                {
                    maxLeft = max(nums1[i - 1], nums2[j - 1]);
                }
                if ((m + n) % 2 == 1)
                {
                    return maxLeft;
                }
                
                int minRight = 0;
                if (i == m)
                {
                    minRight = nums2[j];
                }
                else if (j == n)
                {
                    minRight = nums1[i];
                }
                else
                {
                    minRight = min(nums2[j], nums1[i]);
                }            
                return (maxLeft + minRight) / 2.0;
            }
        }
        return 0.0;
    }
};

Complexity Analysis

• Time complexity: $O(log(min(m,n)))$.
  At first, the searching range id [0, $m$]. And the length of this searching range will be reduced by half after each loop. So, we only need $log(m)$ loops. Since we do constant operations in each loop, the time complexity is $O(log(m))$. Since $m\le n$, the time complexity is $O(log(min(m,n)))$.

• Space complexity:
  We only need constant memory to strore local variables, so the space comlpexity is $O(1)$.