leetcode 第四题 Median of Two Sorted Arrays

        我又来开始继续leetcode的学习啦，第四题很早之前就已经开始做了。问题是这样的，给定两个有序序列，要求两个序列综合后的中位数。关键：算法复杂度 T(n)=O(log(m+n))  。该问题的关键就在于复杂度的限制，有了这个限制，就使得该题目成为一个5星级的难度。

    可惜的是我只找到了一种解决的方法——归并法（类似于鬼归并排序的思路，下面会讲），这种方法的时间复杂度是O(m+n)，但是发现还有时间复杂度更简单的方法，类似于二分查找，看得我头都大了，现在我还没有搞清楚呢，一点点地来吧。

    先说最难的一种方法吧：下面是我摘录的算法的基本原理，我看了之后也是云里雾里的，我看了好多次才看明白，想出这个方法的人真的是。。牛。。

这个解法大概思路很简单，就是A数组的中间元素与B数组的中间元素相比较，从而删掉较小元素所在数组的前一半和较大元素所在数组的后一半。递归下去。

其实要正确实现以上解法还是比较tricky的，因为需要涉及到很多边界情况，我们来一一解释：

第一步，我们需要将题目改为寻找第k小的元素findKthSortedArrays。（这里k从1开始计算）

原因在于，如果我们执着于median，那么在删除一半左右元素形成的子问题中，很难保证仍然是寻找median。可能变为寻找median前一个或者后一个。

（如果仔细思考过这个题就能理解这句话）

改成第k小元素的好处就是，我们可以将删掉的元素考虑进来，在子问题中不断改变k的值。

（例如：本来我们需要寻找的median是第5个数，删掉前面2个数之后，在子问题中就变为寻找第5-2=3个数）

考虑A、B数组总数的奇偶性，就转化为调用findKthSortedArrays的问题了。

第二部：实现findKthSortedArrays

（一）首先，我们规定A数组比B数组短。

这样处理的好处在于：我们所需的(k-1)/2位置可能大于某个数组总长度，规定A短之后，只需要考虑超过A的长度，不需要再复制代码分情况讨论了。

这里需要斟酌一下：为什么不是k/2？ k/2±1？而是(k-1)/2

我的思考如下：

如果k==1,2，就是需要比较头两个元素，因此下标为0

如果k==3,4，就是需要比较第1个元素，因此下标为1

综上归纳而得。

（二）其次，把特殊情况处理掉。

(1)A数组为空时，即返回B数组第k个元素。

(2)k==1时，即返回A[0]、B[0]中小的那个

（三）接下来再分为两种情况：

(k-1)/2位置是否超过A数组长度？

（1）若超过，则A数组派出的代表Acandi就是最后元素A[m-1]，B派出的代表Bcandi是B[k-m-1]

(a)Acandi==Bcandi，那么正好有k-2个元素比Acandi、Bcandi小，所以第k个元素就是Acandi/Bcandi

(b)Acandi > Bcandi，那么最多只有m-1+k-m-1=k-2个元素比Bcandi小，因此包括Bcandi在内之前的k-m个B数组元素肯定不是第k个数，所以删去，子问题变为寻找第k-(k-m)个元素

(c)Acandi < Bcandi，那么最多只有m-1+k-m-1=k-2个元素比Acandi小，因此包括Acandi在内之前的整个A数组元素m个元素肯定不是第k个数，所以删去，子问题变为寻找第k-m个元素

（2）若不超过，则A数组派出的代表Acandi就是A[(k-1)/2]，B派出的代表Bcandi是B[(k-1)/2]

(a)Acandi==Bcandi，那么正好有(k-1)/2+(k-1)/2=k-1个元素比Acandi、Bcandi小，所以第k个元素就是Acandi/Bcandi

如果不相等，对于Acandi 、Bcandi本身是否需要取舍就要注意分析了。

经过举几个例子简单分析就很容易发现，k为奇数时，需要保留小的candidate，舍弃大的。

而k为偶数时，需要保留大的candidate，舍弃小的。

(b)Acandi > Bcandi

(b.1)k为奇数，保留Bcandi，删除Bcandi前面的(k-1)/2个元素，删除A及A后面的元素（保留A中前(k-1)/2个元素）

(b.2)k为偶数，保留Acandi，删除Bcandi及前面的(k-1)/2+1个元素，删除A后面的元素（保留A中前(k-1)/2+1个元素）

(c)Acandi < Bcandi

    哈哈~可能上面也看的很头疼吧~后来我找到了一篇文章能够更清晰的说明这个问题：

1. 中心思想就是：  
2. 这2个数组nums1和nums2中各分成2部分  
3.   
4. nums1[0……pa-1] 和 nums1[pa……s1-1]      （nums1长度为s1）  
5. nums2[0……pb-1] 和 nums2[pb……s2-1]       （nums2长度为s2）  
6.   
7. 其中pa+pb=k,在算法导论中pa=pb=k/2来讨论（因为那里是先把一个数组分成2个已经排好的相等长度的数组），但在这里实际写代码的时候需要考虑数组长度不超过k/2甚至为0的情况

最后从medianof two sorted arrays中看到了一种非常好的方法。原文用英文进行解释，在此我们将其翻译成汉语。该方法的核心是将原问题转变成一个寻找第k小数的问题（假设两个原序列升序排列），这样中位数实际上是第(m+n)/2小的数。所以只要解决了第k小数的问题，原问题也得以解决。

首先假设数组A和B的元素个数都大于k/2，我们比较A[k/2-1]和B[k/2-1]两个元素，这两个元素分别表示A的第k/2小的元素和B的第k/2小的元素。这两个元素比较共有三种情况：>、<和=。如果A[k/2-1]<B[k/2-1]，这表示A[0]到A[k/2-1]的元素都在A和B合并之后的前k小的元素中。换句话说，A[k/2-1]不可能大于两数组合并之后的第k小值，所以我们可以将其抛弃。

证明也很简单，可以采用反证法。假设A[k/2-1]大于合并之后的第k小值，我们不妨假定其为第（k+1）小值。由于A[k/2-1]小于B[k/2-1]，所以B[k/2-1]至少是第（k+2）小值。但实际上，在A中至多存在k/2-1个元素小于A[k/2-1]，B中也至多存在k/2-1个元素小于A[k/2-1]，所以小于A[k/2-1]的元素个数至多有k/2+ k/2-2，小于k，这与A[k/2-1]是第（k+1）的数矛盾。

当A[k/2-1]>B[k/2-1]时存在类似的结论。

当A[k/2-1]=B[k/2-1]时，我们已经找到了第k小的数，也即这个相等的元素，我们将其记为m。由于在A和B中分别有k/2-1个元素小于m，所以m即是第k小的数。(这里可能有人会有疑问，如果k为奇数，则m不是中位数。这里是进行了理想化考虑，在实际代码中略有不同，是先求k/2，然后利用k-k/2获得另一个数。)

通过上面的分析，我们即可以采用递归的方式实现寻找第k小的数。此外我们还需要考虑几个边界条件：

• 如果A或者B为空，则直接返回B[k-1]或者A[k-1]；
• 如果k为1，我们只需要返回A[0]和B[0]中的较小值；
• 如果A[k/2-1]=B[k/2-1]，返回其中一个；

double findKth(int a[], int m, int b[], int n, int k)
{
	//always assume that m is equal or smaller than n
	if (m > n)
		return findKth(b, n, a, m, k);
	if (m == 0)
		return b[k - 1];
	if (k == 1)
		return min(a[0], b[0]);
	//divide k into two parts
	int pa = min(k / 2, m), pb = k - pa;
	if (a[pa - 1] < b[pb - 1])
		return findKth(a + pa, m - pa, b, n, k - pa);
	else if (a[pa - 1] > b[pb - 1])
		return findKth(a, m, b + pb, n - pb, k - pb);
	else
		return a[pa - 1];
}

class Solution
{
public:
	double findMedianSortedArrays(int A[], int m, int B[], int n)
	{
		int total = m + n;
		if (total & 0x1)
			return findKth(A, m, B, n, total / 2 + 1);
		else
			return (findKth(A, m, B, n, total / 2)
					+ findKth(A, m, B, n, total / 2 + 1)) / 2;
	}
};

我们可以看出，代码非常简洁，而且效率也很高。在最好情况下，每次都有k一半的元素被删除，所以算法复杂度为logk，由于求中位数时k为（m+n）/2，所以算法复杂度为log(m+n)。

       这篇文章讲的思路比较清楚。但是这个C++代码并不能在leetcode上面正常运行，现在将它改一下，如下所示：

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size();
        int total = m+n;
        if(total%2 == 1)
            return helper(nums1, m, nums2, n, total/2+1, 0, 0);
        else
            return (helper(nums1, m, nums2, n, total/2, 0, 0) + helper(nums1, m, nums2, n, total/2+1, 0, 0))/2;
    }
    double helper(vector<int>& nums1, int m, vector<int>& nums2, int n, int k, int start1, int start2){
        if(m > n)
            return helper(nums2, n, nums1, m, k, start2, start1);
        if(m == 0)
            return nums2[k-1];
        if(k == 1)
            return min(nums1[start1], nums2[start2]);
        int a = min(k/2, m); //这里的意思是k/2是否超过了nums1数组的长度
        int b = k-a;
        if(nums1[a+start1-1] <= nums2[b+start2-1]){
            return helper(nums1, m-a, nums2, n, k-a, start1+a, start2);
        }
        else{
            return helper(nums1, m, nums2, n-b, k-b, start1, start2+b);
        }
    }
};

        这道题终于告一段落了。。算法实现可真是有魅力啊。。

        继续加油吧！