Leetcode-Median of Two Sorted Arrays

前言

Leetcode刷到150道了，各种题型都已经练习了一遍，没有必要再去刷数量了！分类总结解题方法，完善知识体系已经是刻不容缓了。尤其是在看了《暗时间》之后，深有感触。总结、反思自己的思维过程也许是最重要的。对每道题进行深加工，抽象出一般的概念，得到一般的解题策略。这个过程才是最重要的，是沉淀思想的绝好途径。

先简单摘一些常用的解题方法，以后每碰到难题的时候，都要想一下用这些方法是否可以解决：

• 时刻不忘未知量
  时刻要想到自己的问题是什么，要求什么。

• 用特例启发思考
  构造一个合适的实例，可能会发现一般的规律。

• 反过来推导
  设立未知数，从结论出发，向已知条件靠扰。

• 试错

• 调整题目的条件
  去掉一个条件，观察区别，再放上那个条件，感觉到题目的内在结构上的某种约束，进而得到答案。
• 求解一个类似的题目
  为了优化脑中的知识结构，我们在记忆掌握和分析问题的时候都应该尽量抽象地去看待，这样才能建立知识的本质联系。
• 列出所有可能与题目有关的定理或性质
  比如这道题目，可以列出这样的性质：中位数是数组中最中间的数。如果元素总数为奇数，它左边所有元素的个数和右边所有元素的个数相等；如果为偶数，则将所有元素平分成两左右两部分，两部分元素个数相等， 中位数为最中间两者的均值。
• 考察反面，考察其他所有情况
• 将问题泛化
  这道题应该要进行泛化，比如如果要求两个排序元素里的第K大元素怎么求？如果是n个排序数组呢？

---

题目分析1

Leetcode-CPP_p14可以从结论来推导方法：题目要求用$log(m+n)$的复杂度，而中位数的序号为$i = \frac{m+n}{2}$，要想达到要求的复杂度，则每次查找都应该使$i$减半，即要用到二分搜索。那怎样才能用到二分搜索呢？这一步还不是那么明显，答案是将原问题泛化，寻找两个排序数组的第$k$小的数，然后每步排除$k/2$个数，则最后可以达到复杂度要求。

假设$A,B$两个数组的元素个数都大于$k/2$，那么将$A,B$的第$k$个元素，也就是$A[\frac{k}{2}-1]$和$B[\frac{k}{2}-1]$作比较的话，

$$\left[ \begin{array}{ccc|c} A[0]&A[1]\cdots&A[\frac{k}{2}-1]&A[\frac{k}{2}]\cdots\\ B[0]&B[1]\cdots&B[\frac{k}{2}-1]&B[\frac{k}{2}]\cdots \end{array} \right]$$

可以得到：

$$\begin{cases} A[\frac{k}{2}-1]<B[\frac{k}{2}-1], & \text{(1)} \\ A[\frac{k}{2}-1]>B[\frac{k}{2}-1], & \text{(2)}\\ A[\frac{k}{2}-1]==B[\frac{k}{2}-1], & \text{(3)} \end{cases}$$

对于情形$(1)$，$A[0]\cdots A[\frac{k}{2}-1]$一定是排在$B[\frac{k}{2}-1]$之前，因此$A[0]\cdots A[\frac{k}{2}-1]$绝对不会是第$k$小的数，可以在下一轮寻找中去掉，因此下一轮比较将变成：

$$\left[ \begin{array}{ccc|c} A[\frac{k}{2}]& \cdots&A[\frac{k}{2}+\frac{k}{4}-1]&\cdots\\ B[0]&B[1]\cdots&B[\frac{k}{4}-1]&B[\frac{k}{4}]\cdots \end{array} \right]$$

这里我们不能排除$B$中的元素，是因为我们仅仅知道$A[\frac{k}{2}-1]$与$B[\frac{k}{2}-1]$的大小关系，而不知道$A[\frac{k}{2}-1]$与$B[0]$的关系，$B[0]$可以很大，以至于大于$A[\frac{k}{2}-1]$，而这个时候，其实我们是得不出进一步的结论的，因为我们还是不知道$B[0]$和$A[\frac{k}{2}-1]$后面元素的关系。当然，另一方面，$B[0]$可以比较小，以至于当它增加到$B[\frac{k}{2}-1]$时只比$A[\frac{k}{2}-1]$大了一点点，且小于$A[\frac{k}{2}]$，那么$B[\frac{k}{2}-1]$就是我们要找的第$k$小的数，只是找到它还需要再递归几次。而这并不难分析。

因为我们是要寻找第$k$小的数，永远不要忘了我们的目的是什么——走得太远，不要忘了当初是为什么出发！而我们已经排除了$\frac{k}{2}$个数，因此下一步是寻找第$\frac{k}{2}$（这里的第$\frac{k}{2}$是指包括当前元素的元素个数）小的数，因而又可以排除一半的数，即$\frac{k}{4}$。

情形$(2)$的分析类似；

而情形$(3)$就更简单了，直接可以得到要找的数就是$A[\frac{k}{2}-1]$。因为一定可以得到下面的排列：

$A[0]\cdots A[\frac{k}{2}-2]\cdots B[0]\cdots B[\frac{k}{2}-2] \ A[\frac{k}{2}-1]\ B[\frac{k}{2}-1]$

虽然我们不知道$A\bigcup B$中的前$k-2$个数的具体顺序，但是最后两个数一定是$A[\frac{k}{2}-1], B[\frac{k}{2}-1]$，而最后一个数正是我们要找的第$k$小的数。

算法的正确性

如何证明算法的正确性呢？
每次递归都会排除一半的元素或者排除掉整个数组，即当$\frac{k}{2}>m$，最后一定会得到正确的结果。

代码

int getKth(int a[], int m, int b[], int n, int k)
{
    if (m > n)
        return getKth(b, n, a, m, k);
    if (0 == m)
        return b[k-1];
    if (1 == k)
        return min(a[0], b[0]);
    int i = min((k+1)/2, m);
    /*if (a[i-1] < b[i-1])
        return getKth(a+i, m-i, b, n, k-i);
    else if (a[i-1] > b[i-1])
        return getKth(a, m, b+i, n-i, k-i);*/
    int j = k-i;
    if (a[i-1] < b[j-1])
        return getKth(a+i, m-i, b, n, k-i);
    else if (a[i-1] > b[j-1])
        return getKth(a, m, b+i, n-i, k-j);
    else
        return a[i-1];
}

double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size)
{
    int total = nums1Size+nums2Size;
    if (total & 1) //odd
        return getKth(nums1, nums1Size, nums2, nums2Size, total/2+1);
    else //even
        return (getKth(nums1, nums1Size, nums2, nums2Size, total/2+1) + getKth(nums1, nums1Size, nums2, nums2Size, total/2))/2.0;       
}

代码中注释的地方是有问题的，如果只是比较$A[i-1]$和$B[i-1]$，那么无论$i$是等于$\frac{k}{2}$还是等于$\frac{k+1}{2}$，最后都是不能直接用后面三种情况来处理的。所以我们还需要一个变量$j=k-i$来保证目前我们比较的元素个数为$k$。还是那句话，不要忘了最初的目的是什么。

所以这里的关键在于选出$k$个数，比较每个一维数组的最后一个元素的大小。对于$\frac{k}{n}$大于一维数组的长度$m$的情形，就会越界，这时只能取$m$个元素了，那另外一个数组就必须取$k-m$个元素了，对于$n==2$时，显然$k-m$对于第2个数组是不越界的。但对$n>2$的情形，则情况会复杂很多。

下面是用vector加上迭代器的代码：

int getKthOfVectors(vector<int>& nums1, vector<int>::iterator it1, vector<int>& nums2, vector<int>::iterator it2, int k)
{
    int sz1 = nums1.end()-it1;
    int sz2 = nums2.end()-it2;
    if (sz1 > sz2)
        return getKthOfVectors(nums2, it2, nums1, it1, k);
    if (0 == sz1)
        return *(it2+k-1);
    if (1 == k)
        return min(*it1, *it2);
    int i = min((k+1)/2, sz1);
    int j = k-i;
    if (*(it1+i-1) < *(it2+j-1))
    {
        it1 += i;
        return getKthOfVectors(nums1, it1, nums2, it2, k-i);
    }   
    else if (*(it1+i-1) > *(it2+j-1))
    {
        it2 += j;
        return getKthOfVectors(nums1, it1, nums2, it2, k-j);
    }   
    else
        return *(it1+i-1);
}

double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2)
{
    int total = nums1.size()+nums2.size();  
    if (total & 1) //odd
        return getKthOfVectors(nums1, nums1.begin(), nums2, nums2.begin(), (total+1)/2);
    else //even
        return (getKthOfVectors(nums1, nums1.begin(), nums2, nums2.begin(), total/2+1)+getKthOfVectors(nums1, nums1.begin(), nums2, nums2.begin(), total/2))/2.0;
}

效率

假定$n$是要找的第$n$小的数。则：
$T(n)=T(n/2)+O(1)$，由主定理$\Rightarrow$$T(n)=\log n$。

题目分析2

根据discuss里分享的解答，还可以利用中位数的这一性质：中位数两边的元素个数相等（或相差1）。列出这一性质并不难，难就难在怎么根据这一性质继续往下走。

$$\left[ \begin{array}{ccc|cc} &left\ part&&right\ part\\ A[0]&A[1]\cdots&A[i-1]&A[i]\cdots&A[m-1]\\ B[0]&B[1]\cdots&B[j-1]&B[j]\cdots&B[n-1] \end{array} \right]$$

当左右两部分的元素个数相等或者相差1时，而且$A[i]>B[j-1],B[j]>A[j-1]$，那么中位数就不难找出来了。因此我们只要找出$i$

由此，可列方程$i+j=m-i + n-j$或者$i+j=m-i + n-j +1$

$$\begin{cases} i+j=m-i + n-j , & \text{(m+n为偶数)} \\ i+j=m-i + n-j +1, & \text{(m+n为奇数)} \end{cases}$$

$\Rightarrow$

$$\begin{cases} j=\frac{m+n}{2}-i , & \text{(m+n为偶数)} \\ j=\frac{m+n+1}{2}-i, & \text{(m+n为奇数)} \end{cases}$$

$\Rightarrow$

$j=\frac{m+n+1}{2}-i$(将m+n为奇数和偶数统一起来)

因此我们只要在$0$~$m$中寻找$i$，就可以得到解答，而且由于是寻找中位数，它一定是存大的，就是说我们用binary search来寻找$i$，是一定能找到的。值得注意的是，这里的$i\in [0,m]$，当$i==0$时，$A$全部在left part，当$i==m$时，$A$全部在rigth part部分。

算法的正确性

每次查找，要么找到$i$，要么会缩小查找范围，而$i$一定是存在的，所以最后一定能找到$i$。

代码

double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2)
{
    int sz1 = nums1.size();
    int sz2 = nums2.size();
    if (sz1 > sz2)
        return findMedianSortedArrays(nums2, nums1);
    int imin = 0;
    int imax = sz1;
    int i, j;
    while (imin <= imax)
    {
        i = (imin+imax)/2;
        j = (sz1+sz2+1)/2 - i;
        if (i > 0 && j < sz2 && nums2[j] < nums1[i-1])
            imax = i-1;
        else if (j > 0 && i < sz1 && nums1[i] < nums2[j-1])
            imin = i+1;
        else 
            break;
    }
    int num1;
    if (0 == i)
        num1 = nums2[j-1];
    else if (0 == j)
        num1 = nums1[i-1];
    else
        num1 = max(nums1[i-1], nums2[j-1]);

    if ((sz1+sz2) & 1) //odd
        return num1;

    int num2 = min(nums1[i], nums2[j]);
    return (num1+num2)/2.0;
}

注意：代码最后返回时用到除法，除数要用2.0，否则返回的是int类型转换到double，结果错误。

效率

二分查找的效率当然是$\log_2min(m,n)$。

推广

如果是在$n$个已排序的数组，寻找第$k$小的数，该怎么求呢？
根据思路1，我们可以比较每个数组的第$\frac{k}{n}$个数，如果全部相等，则找到第$k$小的数；否则，可以排除$\frac{(n-1)k}{n}$个数，只有最大的那个元素所在的数组不能排除掉。

上面所说的是理想情况下，实际写代码的时候要考虑的东西稍复杂一些，当数组的元素个数小于$\frac{k}{n}$时，明显就会越界。再有首先得保证，所有数组的元素总数一定大于$k$的。

因此，可以推广为找出二维vector中的第$k$小的数。

接口为：

double findMedianSortedArrays(vector<vector<int>> &nums, int k)

效率又该怎么计算呢？
这里$n$和$k$均有可能是变量，为了更好的与主定理对应，我们用
$n$表示输入的规模，即

$(1)$如果是在$n$个已排序的数组，寻找第$b$小的数

复杂度与$n$其实没有关系，只与$b$有关，因此$T(n)=O(1)$。

$(2)$如果是在$b$个已排序的数组，寻找第$n$小的数

每次递归后$n$都会变成原来的$\frac{1}{b}$$\Rightarrow$$T(n)=T(n/b)+O(1)$，由主定理$\Rightarrow$$T(n)=\log n$。
最坏情况下，每次只能排除一个数，那么时间复杂度就会降为$O(n)$

结语

如果$n$维数组的每维的长度相等，还比较好办。如果每维的长度不等，对于最好情况下的每次递归后规模变成原来的$\frac{1}{n}$就会退化成每次递归后规模只减了1。所以，以上的思路只对2个已经排序的一维数组有比较好的效果。

不管怎么说，第一篇博客，加油！！！