LeetCode(java)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)).

题目描述：给出两个长度分别为m和n的递增数组nums1和nums2，找出若两个数组的中位数（即两个数组整合成一个后的中位数)，时间复杂度应该是：O(log
(m+n)).；

本人解法：

计算若整合两个数组后中位数应该所在的位置K(int)，以及记录是否应该为第K位与第K+1位的平均数half(boolean)，一开始先找出两个数组分别的中位数，比较两个中位数，然后去除小的那个数组的前半部分(K减去消去的位数），以及大的那个数组的后半部分。重复直至其中一个数组长度为2。然后整合两个数组进行排序，找出第k个数。（其实不用排序了，只是比较懒不想写太多条件语句，剩下两个的时候以及可以进行条件判断了，例如a数组还有很长，而b数组只剩下2个了，就有以下几种可能：其中一种最简单的是：b数组的2个数都小于第a数组的第k-2位，若half为假则返回a[k-2]，否则返回(a[k-2]+a[k-1])/2，若哪位大神有兴趣可以试试）

（时间复杂度最佳时（即2个数组等长时）为O(log
(m+n))。

leetcode运行通过时间为9ms(最后通过条件判断不排序的话应该可以快点）。

代码如下：

public class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int len1 = nums1.length;
int len2 = nums2.length;
int len = len1+len2-1;
if(len1<1)
{
int lc = len/2;
if(len%2==0)
return nums2[lc];
else
return (double)(nums2[lc]+nums2[lc+1])/2;
}
else if(len2<1)
{
int lc = len/2;
if(len%2==0)
return nums1[lc];
else
return (double)(nums1[lc]+nums1[lc+1])/2;
}
if(len%2==0)
return solution1(nums1, 0, len1-1, nums2, 0, len2-1, len/2, false);
else
return solution1(nums1, 0, len1-1, nums2, 0, len2-1, len/2, true);
}

private double solution1(int[] a,int aBegin,int aEnd,int[] b,int bBegin,int bEnd,int k,boolean half)
{
if(aEnd-aBegin<=1 || bEnd-bBegin<=1);
{
int lena = aEnd - aBegin + 1;
int lenb = bEnd - bBegin + 1;
int len = lena + lenb;
int[] arr = new int[len];
System.arraycopy(a, aBegin, arr, 0, lena);
System.arraycopy(b, bBegin, arr, lena, lenb);
Arrays.sort(arr);
if(!half)
return arr[k];
else if(half)
return (double)(arr[k]+arr[k+1])/2;
}
int aMid = (aBegin+aEnd)/2;
int bMid = (bBegin+bEnd)/2;
if(a[aMid]>b[bMid])
{
return solution1(a, aBegin, aMid, b, bMid, bEnd, k-(bMid-bBegin), half);
}
else
{
return solution1(a, aMid, aEnd, b, bBegin, bMid, k-(aMid-aBegin), half);
}
}

}

另外转网上大神们写的解法：

复杂度

时间O(log(m+n)) 空间O(1)

思路

题目要求O(log(m+n))的时间复杂度，一般来说都是分治法或者二分搜索。首先我们先分析下题目，假设两个有序序列共有n个元素（根据中位数的定义我们要分两种情况考虑），当n为奇数时，搜寻第(n/2+1)个元素，当n为偶数时，搜寻第(n/2+1)和第(n/2)个元素，然后取他们的均值。进一步的，我们可以把这题抽象为“搜索两个有序序列的第k个元素”。如果我们解决了这个k元素问题，那中位数不过是k的取值不同罢了。

那如何搜索两个有序序列中第k个元素呢，这里又有个技巧。假设序列都是从小到大排列，对于第一个序列中前p个元素和第二个序列中前q个元素，我们想要的最终结果是：p+q等于k-1,且一序列第p个元素和二序列第q个元素都小于总序列第k个元素。因为总序列中，必然有k-1个元素小于等于第k个元素。这样第p+1个元素或者第q+1个元素就是我们要找的第k个元素。

所以，我们可以通过二分法将问题规模缩小，假设p=k/2-1，则q=k-p-1，且p+q=k-1。如果第一个序列第p个元素小于第二个序列第q个元素，我们不确定二序列第q个元素是大了还是小了，但一序列的前p个元素肯定都小于目标，所以我们将第一个序列前p个元素全部抛弃，形成一个较短的新序列。然后，用新序列替代原先的第一个序列，再找其中的第k-p个元素（因为我们已经排除了p个元素，k需要更新为k-p），依次递归。同理，如果第一个序列第p个元素大于第二个序列第q个元素，我们则抛弃第二个序列的前q个元素。递归的终止条件有如下几种：

较短序列所有元素都被抛弃，则返回较长序列的第k个元素（在数组中下标是k-1）
一序列第p个元素等于二序列第q个元素，此时总序列第p+q=k-1个元素的后一个元素，也就是总序列的第k个元素

注意

每次递归不仅要更新数组起始位置（起始位置之前的元素被抛弃），也要更新k的大小（扣除被抛弃的元素）

leetcode通过时间为4ms。

public class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int m = nums1.length, n = nums2.length;
int k = (m + n) / 2;
if((m+n)%2==0){
return (findKth(nums1,nums2,0,0,m,n,k)+findKth(nums1,nums2,0,0,m,n,k+1))/2;
}   else {
return findKth(nums1,nums2,0,0,m,n,k+1);
}

}

private double findKth(int[] arr1, int[] arr2, int start1, int start2, int len1, int len2, int k){
if(len1>len2){
return findKth(arr2,arr1,start2,start1,len2,len1,k);
}
if(len1==0){
return arr2[start2 + k - 1];
}
if(k==1){
return Math.min(arr1[start1],arr2[start2]);
}
int p1 = Math.min(k/2,len1) ;
int p2 = k - p1;
if(arr1[start1 + p1-1]<arr2[start2 + p2-1]){
return findKth(arr1,arr2,start1 + p1,start2,len1-p1,len2,k-p1);
} else if(arr1[start1 + p1-1]>arr2[start2 + p2-1]){
return findKth(arr1,arr2,start1,start2 + p2,len1,len2-p2,k-p2);
} else {
return arr1[start1 + p1-1];
}
}
}

后一种解法转自：http://www.07net01.com/2015/07/871155.html