两个排序数组的中位数

float findMedianSortedArrays(int *a, int lenA, int *b, int lenB)
{
    if (a == NULL || b == NULL || lenA < 1 || lenB < 1)
    {
        return 0;
    }
    int i = 0;
    int j = 0;
    int k = 0;
    int mid = 0;
    int flag = 0;
    int pre = 0;
    if ((lenA + lenB) % 2 == 0)
    {
        flag = 2;
        mid = (lenA + lenB) / 2;
    }
    else
    {
        flag = 1;
        mid = (lenA + lenB + 1) / 2;
    }
    while (k < mid && i < lenA && j < lenB)
    {
        if (a[i] > b[j])
        {
            j++;
            k++;
            pre = 2;
        }
        else
        {
            i++;
            k++;
            pre = 1;
        }
    }

    if (k == mid)
    {
        if (pre == 1)
        {
            if (flag == 1)
            {
                return a[i - 1];
            }
            if (flag == 2)
            {
                if (j == 0)
                {
                    if (i < lenA && a[i] < b[j])
                    {
                        return (float)(a[i - 1] + a[i])/2;
                    }
                    else
                    {
                        return (float)(a[i - 1] + b[j])/2;
                    }
                }
                else
                {
                    if (i < lenA && a[i] < b[j])
                    {
                        return (float)(a[i - 1] + a[i])/2;
                    }
                    else
                    {
                        return (float)(a[i - 1] + b[j])/2;
                    }
                }
            }
        }
        if (pre == 2)
        {
            if (flag == 1)
            {
                return b[j - 1];
            }
            if (flag == 2)
            {
                if (i == 0)
                {
                    if (j < lenB && b[j] < a[i])
                    {
                        return (float)(b[j - 1] + b[j])/2;
                    }
                    else
                    {
                        return (float)(b[j - 1] + a[i])/2;
                    }
                }
                else
                {
                    if (j < lenB && b[j] < a[i])
                    {
                        return (float)(b[j - 1] + b[j])/2;
                    }
                    else
                    {
                        return (float)(b[j - 1] + a[i])/2;
                    }
                }
            }
        }
    }
    else if (i == lenA)
    {
        if (flag == 1)
        {
            return b[j + mid - k -1];
        }
        if (flag == 2)
        {
            return (float)(b[j + mid - k - 1] + b[j + mid - k])/2;
        }
    }
    else if (j == lenB)
    {
        if (flag == 1)
        {
            return a[j + mid - k -1];
        }
        if (flag == 2)
        {
            return (float)(a[j + mid - k - 1] + a[j + mid - k])/2;
        }
    }
}

Median of Two Sorted Arrays

There are two sorted arrays A and B 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)).

标签: Divide and Conquer Array Binary Search
分析

这是一道非常经典的题。这题更通用的形式是，给定两个已经排序好的数组，找到两者所有元素中第$k$大的元素。

$O(m+n)$的解法比较直观，直接merge两个数组，然后求第$k$大的元素。

不过我们仅仅需要第$k$大的元素，是不需要“排序”这么复杂的操作的。可以用一个计数器，记录当前已经找到第$m$大的元素了。同时我们使用两个指针{pA}和{pB}，分别指向A和B数组的第一个元素，使用类似于merge sort的原理，如果数组A当前元素小，那么{pA++}，同时{m++}；如果数组B当前元素小，那么{pB++}，同时{m++}。最终当$m$等于$k$的时候，就得到了我们的答案，$O(k)$时间，$O(1)$空间。但是，当$k$很接近$m+n$的时候，这个方法还是$O(m+n)$的。

有没有更好的方案呢？我们可以考虑从$k$入手。如果我们每次都能够删除一个一定在第$k$大元素之前的元素，那么我们需要进行$k$次。但是如果每次我们都删除一半呢？由于A和B都是有序的，我们应该充分利用这里面的信息，类似于二分查找，也是充分利用了“有序”。

假设A和B的元素个数都大于$k/2$，我们将A的第$k/2$个元素（即{A[k/2-1]}）和B的第$k/2$个元素（即{B[k/2-1]}）进行比较，有以下三种情况（为了简化这里先假设$k$为偶数，所得到的结论对于$k$是奇数也是成立的）：

\item {A[k/2-1] == B[k/2-1]}
\item {A[k/2-1] > B[k/2-1]}
\item {A[k/2-1] < B[k/2-1]}

如果{A[k/2-1] < B[k/2-1]}，意味着{A[0]}到{A[k/2-1}的肯定在$A \cup B$的top k元素的范围内，换句话说，{A[k/2-1}不可能大于$A \cup B$的第$k$大元素。留给读者证明。

因此，我们可以放心的删除A数组的这$k/2$个元素。同理，当{A[k/2-1] > B[k/2-1]}时，可以删除B数组的$k/2$个元素。

当{A[k/2-1] == B[k/2-1]}时，说明找到了第$k$大的元素，直接返回{A[k/2-1]}或{B[k/2-1]}即可。

因此，我们可以写一个递归函数。那么函数什么时候应该终止呢？

\item 当A或B是空时，直接返回{B[k-1]}或{A[k-1]}；
\item 当{k=1}是，返回{min(A[0], B[0])}；
\item 当{A[k/2-1] == B[k/2-1]}时，返回{A[k/2-1]}或{B[k/2-1]}

代码1

view source

01	// LeetCode, Median of Two Sorted Arrays

02	// 时间复杂度O(log(m+n))，空间复杂度O(log(m+n))

03	class Solution {

04

public:

05	double findMedianSortedArrays(int A[], int m, int B[], int n) {

06	int total = m + n;

07	if (total & 0x1)

08	return find_kth(A, m, B, n, total / 2 + 1);

09

else

10	return (find_kth(A, m, B, n, total / 2)

11	+ find_kth(A, m, B, n, total / 2 + 1)) / 2.0;

12

}

13

private:

14	static int find_kth(int A[], int m, int B[], int n, int k) {

15	//always assume that m is equal or smaller than n

16	if (m > n) return find_kth(B, n, A, m, k);

17	if (m == 0) return B[k - 1];

18	if (k == 1) return min(A[0], B[0]);

19

20	//divide k into two parts

21	int ia = min(k / 2, m), ib = k - ia;

22	if (A[ia - 1] < B[ib - 1])

23	return find_kth(A + ia, m - ia, B, n, k - ia);

24	else if (A[ia - 1] > B[ib - 1])

25	return find_kth(A, m, B + ib, n - ib, k - ib);

26

else

27	return A[ia - 1];

28

}

29

};