Question

我试图理解this solution找到两个排序数组的中位数的问题：

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);
}

我无法理解的第一部分是findKth方法中定义的aMid和bMid如何表示A和B的中间计数。我手工完成了几个例子，我可以看到，实际上，在比较A [aMid]和B [bMid]之后，只剩下一半的元素总数。但这两个指数的定义背后的想法是什么？为什么在比较A [aMid]和B [bMid]之后只剩下一半的元素？有人可以解释一下这个解决方案吗？

Answer 1

说A [] = {1,5,6,7,8,9}和B [] = {2,3,4}，所以A []和B []的中位数应为5，让＆＃39; s浏览代码。

findMedianSortedArrays（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）
- aMid = 3 * 2 /（3 + 1）= 1，bMid = 2-1-1 = 0，因为A [1] = 5> B [bMid + bStart] = B [2] = 4，所以k = 2-（2-2 + 1）= 1，aEnd = 1，bStart = 3
findKth（A，B，1,0,1,3,2）
- bLen = 0，返回A [aStart + k] = A [0 + 1] = A [1] = 5

总体思路是：

根据数组长度的权重，获取数组的可能median。（参见aMid和bMid）
比较A [aMid]和B [bMid]，if（A [aMid]＆gt; B [bMid]），表示：
- 对于B [bStart..bMid]中的所有元素，它应该在中位数的左边，这是容易的部分
- 对于A [aMid + 1..aEnd]中的所有元素，它应该在中位数的右侧。那是因为（aMid-aStart + bMid-bStart）已经等于（aLen + bLen）/ 2，并且在数组中位数左边的B [aMid + 1..aEnd]中可能有额外的元素。
- 因此我们将两个数组减少到一半，这就是运行时复杂度应为O（log（m + n））的原因。
在A [aStart..aMid]和B [bMid + 1..bEnd]中找到midian是递归的。

Answer 2

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;
        
    }

以对数时间查找两个排序数组的中位数

2 个答案: