Java 在对数时间内求两个排序数组的中值

我试图理解查找两个排序数组的中间值的问题：

public static double findMedianSortedArrays(int A[], int B[]) {
    int m = A.length;
    int n = B.length;

    if ((m + n) % 2 != 0) // odd
        return (double) findKth(A, B, (m + n) / 2, 0, m - 1, 0, n - 1);
    else { // even
        return (findKth(A, B, (m + n) / 2, 0, m - 1, 0, n - 1) 
            + findKth(A, B, (m + n) / 2 - 1, 0, m - 1, 0, n - 1)) * 0.5;
    }
}

public static int findKth(int A[], int B[], int k, 
    int aStart, int aEnd, int bStart, int bEnd) {

    int aLen = aEnd - aStart + 1;
    int bLen = bEnd - bStart + 1;

    // Handle special cases
    if (aLen == 0)
        return B[bStart + k];
    if (bLen == 0)
        return A[aStart + k];
    if (k == 0)
        return A[aStart] < B[bStart] ? A[aStart] : B[bStart];

    int aMid = aLen * k / (aLen + bLen); // a's middle count
    int bMid = k - aMid - 1; // b's middle count

    // make aMid and bMid to be array index
    aMid = aMid + aStart;
    bMid = bMid + bStart;

    if (A[aMid] > B[bMid]) {
        k = k - (bMid - bStart + 1);
        aEnd = aMid;
        bStart = bMid + 1;
    } else {
        k = k - (aMid - aStart + 1);
        bEnd = bMid;
        aStart = aMid + 1;
    }

    return findKth(A, B, k, aStart, aEnd, bStart, bEnd);
}

public静态双findMediansortedarray（inta[]，intb[]{
int m=A.长度；
int n=B.长度；
如果（（m+n）%2！=0）//奇数
返回（双）findKth（A，B，（m+n）/2，0，m-1，0，n-1）；
否则{//偶数
返回（findKth（A，B，（m+n）/2，0，m-1，0，n-1）
+findKth（A，B，（m+n）/2-1,0，m-1,0,n-1））*0.5；
}
}
公共静态int findKth（int A[]，int B[]，int k，
int aStart、int aEnd、int bStart、int bEnd）{
int aLen=aEnd-aStart+1；
int bLen=弯曲-开始+1；
//处理特殊情况
如果（aLen==0）
返回B[B开始+k]；
如果（bLen==0）
返回一个[aStart+k]；
如果（k==0）
返回A[aStart]B[bMid]）{
k=k-（体重指数-b开始+1）；
aEnd=中间；
b开始=体重指数+1；
}否则{
k=k-（中间-aStart+1）；
bEnd=bMid；
aStart=aMid+1；
}
返回findKth（A、B、k、aStart、aEnd、bStart、bEnd）；
}

---

我无法理解的第一部分是findKth方法中定义的aMid和bMid如何表示A和B的中间计数。我手边看了几个例子，我发现，事实上，在比较a[aMid]和B[bMid]之后，只有一半的元素仍然存在。但定义这两个指数背后的想法是什么？为什么在比较A[aMid]和B[bMid]之后只剩下一半的元素？有人能给我解释一下这个解决方案吗？

假设A[]={1,5,6,7,8,9}和B[]={2,3,4}，那么A[]和B[]的中值应该是5，让我们浏览一下代码

FindMediansortedArray（A，B），m=6，n=3

findKth（A、B、4、0、5、0、2）

• aMid=6*4/（6+3）=2，bMid=4-2-1=1，因为a[2]=6>b[1]=3，所以k=4-（1-0+1）=2，aEnd=2，bStart=2

findKth（A，B，2，0，2，2，2，2）

• aMid=3*2/（3+1）=1，bMid=2-1-1=0，因为A[1]=5>B[bMid+B开始]=B[2]=4，所以k=2-（2-2+1）=1，aEnd=1，B开始=3

findKth（A、B、1、0、1、3、2）

• bLen=0，返回A[aStart+k]=A[0+1]=A[1]=5

---

因此，总体思路是：

根据数组长度的权重，得到数组可能的

中值。（参考AMD和bMid）

比较A[aMid]和B[bMid]，如果（A[aMid]>B[bMid]），这意味着：

• 对于B[bStart..bMid]中的所有元素，它应该位于中间值的左侧，这是最简单的部分
• 对于[aMid+1..aEnd]中的所有元素，它应该位于中间带的右侧。这是因为（ambid aStart+bMid bStart）已经等于（aLen+bLen）/2，并且在数组中位数左侧的B[ambid+1..aEnd]中可能有额外的元素
• 因此，我们将两个数组的大小都减少到一半，这就是运行时复杂性应为O（log（m+n））的原因

所以递归地在A[aStart..aMid]和B[bMid+1..bEnd]中找到米甸人

java的基本方式

  public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        double res;
        int arr[] = new int[nums1.length+nums2.length];
        
        for(int i= 0; i<nums1.length; i++){            
            arr[i] = nums1[i];
        }
        
        for(int i = nums1.length, j = 0; i<nums1.length+nums2.length; i++, j++){            
            arr[i] = nums2[j];
        }
        Arrays.sort(arr);
        if(arr.length == 1)res = arr[0];
        else {
            
            if(arr.length % 2 == 0)res = ((arr[arr.length/2]+arr[(arr.length/2)-1])/2.0);
            else{
                res = arr[(arr.length/2)];
            }
            
        }
        
        return res;
        
    }

公共双FindMediaTransortedArray（int[]nums1，int[]nums2）{
双res；
int arr[]=new int[nums1.length+nums2.length]；
对于（int i=0；i