leetcode4. 寻找两个正序数组的中位数

题目来源：题目

参考题解：题解

题目

给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。

 

请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

 

你可以假设 nums1 和 nums2 不会同时为空。

 

 

 

示例 1:

 

nums1 = [1, 3]

nums2 = [2]

 

则中位数是 2.0

示例 2:

 

nums1 = [1, 2]

nums2 = [3, 4]

 

则中位数是 (2 + 3)/2 = 2.5

思路

思路一(合并为一个大数组)

       可以采用归并排序中将两个有序数组合并成一个数组的思想，开创一个容量为num1长度和num2长度和的大数组，将原本有序的两个小数组合并成一个大数组。如果大数组的长度为奇数，直接取出最中间的一个元素。如果大数组长度为偶数，去除中间两个数字求平均。

思路二（直接找到所在位置的数值，不用合并数组）

       设数组一的长度为m,数组二的长度为n.

和思路一的想法差不多，不需要开辟空间，直接用两个指针分别指向两个数组，每次往后移动数组较小的那个指针，知道移动到中位数的位置即可。

因为m+n有奇数和偶数两种情况，对于总长度为奇数的话，我们需要找到第（m+n） / 2 + 1小的元素。对于总长度为偶数的情况，我们需要找到第（m+n） / 2和（m+n）/2+1小的元素的平均值。所以对于这两种情况，我们都需要找（m+n）/2+1次，分别用left和right记录每次找到的元素。最后根据奇偶判断返回值。

思路三（找第k小数）

       这道题可以转换为求第K小的数，要求中位数，就是求第（m+n+1）/2小的数。思路二指针每次往前移动一个，相当于每次剔除掉一个比第（m+n+1）/2小的数还小的数。

然而每次剔除掉一个数速度太慢，我们要求第k小的数，每次可以分别在两个数组找到前k/2个数字，根据他们的相对大小，每次都剔除k/2个数字，直到最后再剩余的数组中找找第1小的数字，则直接比较两个数组的头元素即可。

递归代码如下所示，详细的算法讲解比如边界条件判断，算法正确性证明等可以在上面的题解链接查看。

思路四

将两个数组分别在第i和位置和第j个位置切割，并将分别将左右合并成两个数组，然后左边的最大值和右边的最小值就是中位数。

重点要找i和j个位置。

代码

思路一代码

public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
    int m = nums1.length;
    int n = nums2.length;
    int []nums = new int[m + n];
    int p1 = 0,p2 = 0,count = 0;
    while(count < m + n){
        if(p1 == m){
            while(p2 < n){
                nums[count++] = nums2[p2++];
            }
        } else if(p2 == n){
            while(p1 < m){
                nums[count++] = nums1[p1++];
            }
        }else {
            if(nums1[p1] <= nums2[p2])nums[count++] = nums1[p1++];
            else nums[count++] = nums2[p2++];
        }
    }
    if((m + n) % 2 == 0){
        return (double)(nums[(m + n) / 2] + nums[(m + n) / 2 - 1]) / 2;
    }else {
        return nums[(m + n) / 2];
    }
}

思路二代码

public static double findMedianSortedArrays(int[] nums1, int[] nums2) {

    int m = nums1.length;

    int n = nums2.length;

    int p1 = 0,p2 = 0,left = 0,right = 0,count = 0;

    while(count <= (m + n) / 2){

        left = right;

        if(p1 == m){

            right = nums2[p1++];

        }else if(p2 == n){

            right = nums1[p2++];

        }else {

            if(nums1[p1] <= nums2[p2]){

                right = nums1[p1++];

            }else {

                right = nums2[p2++];

            }

        }

        count++;

    }

    if((m + n) % 2 == 0){

        return (double)(left + right) / 2;

    }else {

        return right;

    }

}

 

思路三代码

public static double findMedianSortedArrays(int[] nums1, int[] nums2) {

    int m = nums1.length;

    int n = nums2.length;

    return (getKth(nums1,0,m - 1,nums2,0,n - 1,(m + n + 1) / 2) + getKth(nums1,0,m - 1,nums2,0,n - 1,(m + n + 2) / 2)) * 0.5;

}

public static int getKth(int nums1[],int start1,int end1,int nums2[],int start2,int end2,int k){

    int len1 = end1 - start1 + 1;

    int len2 = end2 - start2 + 1;

    if(len1 > len2)return getKth(nums2,start2,end2,nums1,start1,end1,k);

    if(len1 == 0)return nums2[start2 + k - 1];

    if(k == 1)return Math.min(nums1[start1],nums2[start2]);

    int i = start1 + Math.min(len1,k / 2) - 1;

    int j = start2 + Math.min(len2, k / 2) - 1;

    if(nums1[i] > nums2[j]){

        return getKth(nums1,start1,end1,nums2,j + 1,end2,k - (j - start2 + 1));

    }else {

        return getKth(nums1,i + 1,end1,nums2,start2,end2,k - (i - start1 + 1));

    }

}

思路四代码

public static double findMedianSortedArrays(int[] nums1, int[] nums2) {

    int m = nums1.length;

    int n = nums2.length;

    if(m > n){

        return findMedianSortedArrays(nums2,nums1);

    }

    int iMin = 0,iMax = m;

    while (iMin <= iMax) {

        int i = (iMin + iMax) / 2;

        int j = (m + n + 1) / 2 - i;

        if (j != 0 && i != m && nums2[j-1] > nums1[i]){ // i 需要增大

            iMin = i + 1;

        }

        else if (i != 0 && j != n && nums1[i-1] > nums2[j]) { // i 需要减小

            iMax = i - 1;

        }

        else { // 达到要求，并且将边界条件列出来单独考虑

            int maxLeft = 0;

            if (i == 0) { maxLeft = nums2[j-1]; }

            else if (j == 0) { maxLeft = nums1[i-1]; }

            else { maxLeft = Math.max(nums1[i-1], nums2[j-1]); }

            if ( (m + n) % 2 == 1 ) { return maxLeft; } // 奇数的话不需要考虑右半部分



            int minRight = 0;

            if (i == m) { minRight = nums2[j]; }

            else if (j == n) { minRight = nums1[i]; }

            else { minRight = Math.min(nums2[j], nums1[i]); }



            return (maxLeft + minRight) / 2.0; //如果是偶数的话返回结果

        }

    }

    return 0.0;

}

总结

思路一和思路二的时间复杂度为O(m+n).

思路三和思路四由于都用了二分查找，时间复杂度都降到了log级别。