leetcode 4: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)).

难点：需要在O(log (m+n))内完成。

//采用数组合并的思想,然后取其第k个数,但是时间复杂度为O(m+n),不符合O(log(m+n))
public static double findMedianSortedArrays(int[] nums1,int[] nums2)
{

int length1,length2,length,i=0,j=0,indexx = 0,indexy = 0;
int flag = 0;
length1 = nums1.length;
length2 = nums2.length;
length = length1 + length2;
double res;

if (length % 2 ==0)
{
flag = 0;
indexx = length/2 - 1;
indexy = length/2;
}else
{
flag = 1;
indexx = length / 2;
}

int[] nums3 = new int[length];
int k = 0;

while ( i < length1 && j <length2 )
{
nums3[k++] = nums1[i] < nums2[j] ? nums1[i++]:nums2[j++];
}

if ( k > (length / 2))
{
if (flag == 0)
res = (double)(nums3[indexx]+nums3[indexy])/2.0;
else
res = (double)nums3[indexx];
}
else if (k == (length / 2))
{
if (i < length1)
if (flag == 0 )
res = (double)(nums3[k-1] + nums1[i])/2.0;          //i  此时指向 nums1 的下一个元素,k-1表示当前合并nums3的最后一个元素
else
res = (double)nums1[i];
else
if (flag == 0)
res = (double)(nums3[k-1] + nums2[j])/2.0;
else
res = (double)nums2[j];
}
else
{

if (i < length1)
{
if (flag == 0)
res = (double)(nums1[i + length/2 - k - 1] + nums1[i + length/2 - k])/2.0;
else
res = (double)nums1[i + length/2 - k];

}
else {
if (flag == 0)
res = (double) (nums2[j + length/2 - k - 1] + nums2[j + length/2 - k]) / 2.0;
else
res = (double) nums2[j + length/2 - k];

}

}

return res;

}

查找O(logn)想到二分应该很理所当然
/**
* 类似二分查找，复杂度O(log(m+n))
* 第一步，我们需要将题目改为寻找第k小的元素findKthSortedArrays。（这里k从1开始计算）
* 第二部：实现findKthSortedArrays
* @param nums1,nums2
*/

public static double betterSolution(int[] nums1,int[] nums2)
{
int m = nums1.length;
int n = nums2.length;
if ((m + n) % 2 == 0 )
return (findKthSortedArrays(nums1,m,nums2,n,(m + n)/2)+findKthSortedArrays(nums1,m,nums2,n,(m + n)/2 + 1)) / 2.0;
else
return findKthSortedArrays(nums1,m,nums2,n,(m + n)/2 +1);

}

public static double findKthSortedArrays(int[] A , int m , int[] B ,int n , int k)
{
//首先确定A的长度比B小
if (m > n)
return findKthSortedArrays(B,n,A,m,k);

//特殊情况:A为空的时候  不拿出来,会导致空指针异常  第k个元素 在数组中的下标为k - 1
if (m == 0)
return B[k - 1];

//特殊情况2: k == 1 取第一个,此时 m已经确保大于 0
if (k == 1)
return Math.min(A[0],B[0]);

int Acandi,Bcandi;              //A , B中选出的那个关键位置

//这里需要斟酌一下：为什么不是k/2？ k/2±1？而是(k-1)/2
//我的思考如下：
//如果k==1,2，就是需要比较头两个元素，因此下标为0
//如果k==3,4，就是需要比较第1个元素，因此下标为1
if ((k - 1) / 2 >= m)
{
//数组下标是k,前面还有k个数
//此时A[(kth-1)/2]已经越界 Acandi只能取A[m-1]  则Bcandi取 B[kth - m -1]
Acandi = A[m-1];
Bcandi = B[k - m - 1];

if (Acandi == Bcandi)
return Acandi;          //或者Bcandi 此时正好有m-1+k-m-1 = k -2 个数 比Acandi小

//Acandi > Bcandi时
//此时最多只有k-2个数比B[k - m -1 ]要小,也就是说Bcandi必然不可能是第k位,当时Acandi仍有可能是
//所以A不变,舍弃B的前k-m个数, 下标从k-m到n-1,copyOfRange from应该是首元素下标,to是末元素下标+1
else if (Acandi > Bcandi)
return findKthSortedArrays(A,m, Arrays.copyOfRange(B,k-m,n),n-(k-m),k-(k-m));
else
return B[k-m-1];

}

else
{
//k=1,2->index 0; k =3,4->index1
Acandi = A[(k-1)/2];
Bcandi = B[(k-1)/2];

if (Acandi == Bcandi)
return Acandi;

else if (Acandi > Bcandi)
{
//Acandi前面有(k-1)/2个数,Bcandi同理,所以这个序列总共有k+1个数,其中Acandi最大
//最多只有k-1个数比Bcandi小,所以第k个数最小是Bcandi,最大是Acandi前一位(所以B的前半段,和A以及A的后半段肯定要删去的)
//这种只是在我们事实上寻找的中间位就是K的情况下(当k为奇数时,没有偏差)
//但当k为偶数时,偏移量需要往后一位,那就是第k个数最小是Bcandi后一位了,最大是Acandi,即保留A 删除B
//k为偶数时，最多只有k-2个数比Bcandi小，所以第k个数是最大是A，最小是Bcandi的后一位
//eg.k=8 时，A[3]>B[3],前面就只有6个数， 所以B[3]不可能是第8个

//k值的改变是根据第k个之前的数被删多少而改变的, 后半段的删除不会造成影响
if (k % 2 == 1)
//保留B,删除A
return findKthSortedArrays(Arrays.copyOfRange(A,0,(k-1)/2),(k-1)/2,Arrays.copyOfRange(B,(k-1)/2,n),n - (k-1)/2,k-(k-1)/2);

else
//保留A,删除B
return findKthSortedArrays(Arrays.copyOfRange(A,0,(k-1)/2 + 1),(k-1)/2 + 1,Arrays.copyOfRange(B,(k-1)/2 +1,n),n -((k-1)/2+1),k- ((k-1)/2 +1));

}
else
{
if (k % 2 == 1)
return findKthSortedArrays(Arrays.copyOfRange(A,(k-1)/2,m),m - (k-1)/2,Arrays.copyOfRange(B,0,(k-1)/2),(k-1)/2,k-(k-1)/2);
else
return findKthSortedArrays(Arrays.copyOfRange(A,(k-1)/2 + 1,m),m-((k-1)/2+1),Arrays.copyOfRange(B,0,(k-1)/2 + 1),(k-1)/2 + 1,k- ((k-1)/2 +1));

}

}

}