[leetcode]Median of Two Sorted Arrays

4. Median of Two Sorted Arrays

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)). 

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

这题大致有两种解法，第一种使用中位数的定义（将有序数组分为同等两部分）然后通过二分法寻找满足中位数的切割。
第二种解法比较通俗易懂，利用另外一个问题：在两个有序数组中找k-th小的数。
Let’s say we have two arrays:
$a_0,a_1,a_2,...,a_{m-1}$
$b_0,b_1,b_2,...,b_{n-1}$
The array after merging two arrays:
$c_0,c_1,c_2,...,c_{m+n-1}$
goal: find $k_{th}$ smallest number of merged array, which is $c_{k-1}$
Theorem: say if $a_{k/2-1} < b_{k/2-1}$, then numbers $a_{k/2-1}$ and its left side elements are all smaller than $k_{th}$ smallest number of the merged array:$c_{k-1}$.
$a_{k/2-1}$ and its left side elements: $a_0, a_1,...,a_{k/2-1}$.
Assume that $c_{k-1} = a_{k/2-1}$:
In the merged array, there are $k-1$ elements smaller than$c_{k-1}$.
In the first array, there are $k/2 - 1$ elements smaller than $c_{k-1} = a_{k/2-1}$.
In the second array, there are at most $k/2 - 1$ elements smaller than $c_{k-1} = a_{k/2-1}< b_{k/2-1}$.
Thus there are at most $k - 2$ elements smaller than$c_{k-1}$, which is a contradiction.

How to use this theorem?
$find(a, b, k)$
Compare$a_{k/2-1}$ with $b_{k/2-1}$,
if $a_{k/2-1} < b_{k/2-1}$, return $find(a+k/2, b, k/2)$
else return $find(a, b + k/2, k/2)$
So the median of two sorted arrays could be solved in $O(log(m+n))$.

class Solution 
{
private:
    int k_th(vector<int>::iterator a, int m, vector<int>::iterator b, int n, int k)
    {
        if (m < n) return k_th(b, n, a, m, k);
        if (n == 0) return *(a + k - 1);
        if (k == 1) return min(*a, *b);

        int j = min(k / 2, n);
        int i = k - j;
        if (*(a + (i - 1)) > *(b + (j - 1)))
            return k_th(a, i, b + j, n - j, k - j);
        return k_th(a + i, m - i, b, j, k - i);
    }
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) 
    {
        int m = nums1.size(), n = nums2.size();
        int m1 = k_th(nums1.begin(), m, nums2.begin(), n, (m + n) / 2 + 1);
        if ((m + n) % 2 == 0)
            return (m1 + k_th(nums1.begin(), m, nums2.begin(), n, (m + n) / 2)) / 2.0;
        return m1;
    }
};