寻找两个有序数组的中位数（附上三种解法）

目录

•写在前面

•题目

•解法一

•解法二

•解法三

•结束

---

•写在前面

这道题比较经典，我当时在做的时候，想出了两种解决方案，不过总感觉算法不够优美，所以找到了另一种我觉得非常精妙的解法，利用了K最小数的思想去解决这道题，很值得讲一下，不知道K最小数的，可以参考我另一篇文章，点击这里跳转就可以了。下面我废话不多说，直接开始讲解。

•题目

首先先把题目呈上来，具体题目如下：

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。请你找出这两个有序
数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。你可以假
设 nums1 和 nums2 不会同时为空。
测试用例：
nums1 = [1, 3]
nums2 = [2]
测试结果：则中位数是 2.0

•解法一

怎么说解法一呢，其实可以把解法一当成暴力解法，对这道题进行硬解。但是如果仔细看要求的话就会发现，题目里要求了时间复杂度是O(log(m + n))，所以这种解法不能满足要求，不过因为我当时先看到的是没有O(log(m + n))要求的题目，所以就直接暴力解决了（对于有些题目，暴力不失为一种省力的好办法，小声bb）。这个解法没什么好讲的，我就大概说一下思路。

具体思路就是，将两个数组使用归并的思想，进行整合，然后求解。（ps：别说直接合起来，然后排序，你要是这样做的话，算法老师的棺材板都压不住），直接上代码。当然啦，下面代码直接整合成了一个数组，其实我们也可以不用真的整合数组，只要通过不断比对，然后记录值就可以了（注意边界问题）。这种解法的时间复杂度是O(m + n)哦。

public static double Test4S2(int[] nums1, int[] nums2) {
        List<Integer> array = new ArrayList<>(10);

        int size1 = nums1.length;
        int size2 = nums2.length;
        int index1 = 0;
        int index2 = 0;

        while(index1 != size1 || index2 != size2){
            if(index1 == size1){
                for (int i = index2; i < size2; i++){
                    array.add(nums2[i]);
                }
                break;
            }else if (index2 == size2){
                for (int i = index1; i < size1; i++){
                    array.add(nums1[i]);
                }
                break;
            }
            array.add(nums1[index1] < nums2[index2] ? nums1[index1] : nums2[index2]);
            if(nums1[index1] < nums2[index2]){
                if(index1 < size1)
                    index1++;
            }
            else{
                if(index2 < size2) index2++;
            }
        }

        int sizeArray = array.size() / 2;
        if(array.size() % 2 == 0) return (array.get(sizeArray - 1) +         array.get(sizeArray)) / 2.00;
        else return array.get(sizeArray);
    }

•解法二

在考虑题目时间复杂度O(log(m + n))的情况下，我换了一种解法，这种解法也没啥精妙的地方，主要是对中位数的概念理解好了，就容易想到。首先很多时候，我们看到了log一般就要想到二分法。

具体思路，中位数的概念其实可以理解为，将数组整体分为两个部分，一边大于等于中位数，一边小于等于中位数。那么在这道题目中两个有序数组，我们可以将两个数组并排画一条线，这条线能正好划分左右两个部分，而我们的任务就是要找到这条线。可能形容起来比较吃力，话不多说，上图看。

就是为了找到i，j连起来的线，能够正好将两个数组划分成左右两个部分，划分好了之后，只需要记录左边最大的值和右边最小的值，通过这两个值求解中位数就可以了，研究之后你就会发现i和j的关系是

i + j = m - i  + n - j

因为左边部分和右边部分的数量要相等，有了这个之后，我们只要最开始随机确定i（直接在小数组中间取i），然后通过左右移动i（j移动的方向和i相反）找到我们要的那条线。不过一定要小心边界问题，对于边界要进行处理好哦。代码如下

public static double Test4S3(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        if (m > n) {
            return Test4S3(nums2,nums1); // 保证 m <= n
        }
        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;
    }

•解法三

最激动人心的解法来了，我当时看到这个解法的时候，感叹连连，解法非常的精妙有容易理解，利用第K小数的思想，使用递归二分法进行解决。

具体思路，中位数其实就是第（总长度）/2小的数（奇偶我就不多说了，为了方便我就直接用奇数了），以为两个数组都是有序的，所以我们每次通过循环排除K的一半，直到最后找到K。看图看图，已这个例子为例，我们要找的K是7.

这个时候K/2等于3，然后我们比较两个数组的第三个位置上的数，就可以排除小的那一边的三个数一定不是第K小，然后我们这个时候将排除的数标记。

这个时候因为我们已经排除了3个数，接下来我们只要在新的两个数组中，找到K-3也就是第4小的数就可以了，同样的，将K比较K一半为止的数，重复如此

所以我们采用递归的思路，为了防止数组长度小于 k/2，所以每次比较 min(k/2，len(数组) 对应的数字，把小的那个对应的数组的数字排除，将两个新数组进入递归，并且 k 要减去排除的数字的个数。递归出口就是当 k=1 或者其中一个数字长度是 0 了。直接上代码。

    private static int kMinNum(int start1, int end1, int[] nums1, int start2, int end2, int[] nums2, int k){
        int len1 = end1 - start1 + 1;
        int len2 = end2 - start2 + 1;
        if(len1 > len2) return kMinNum(start2, end2, nums2, start1, end1, nums1, 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 kMinNum(start1, end1, nums1, j + 1, end2, nums2,k - (j - start2 + 1));
        }else{
            return kMinNum(i + 1, end1, nums1, start2, end2, nums2, k - (i - start1 + 1));
        }
    }

    public static double Test4S1(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int m = nums2.length;
        int left = (n + m + 1) / 2;
        int right = (n + m + 2) / 2;
        return (kMinNum(0, n - 1, nums1, 0, m - 1, nums2, left) + kMinNum(0, n - 1, nums1, 0, m - 1, nums2, right)) * 0.5;
    }

•结束

第三种解法真的感觉相当的精妙，这种思路很值得去吃透理解。