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

问题描述

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

解决思路

方法一

合并数组排序，返回中位数

//方法一：O(m+n)  合并数组 在合并时用归并速度更快  返回中位数
    //方法二：在归并是不用归并完  比到中位数的位置就停止  不过时间还是O(m+n)
    public double findMedianSortedArrays1(int[] nums1, int[] nums2) {

        int m = nums1.length;
        int n = nums2.length;
        int[] num = new int[m + n];

        for (int i = 0; i < nums1.length; i++) {
            num[i] = nums1[i];
        }
        for (int i = 0; i < nums2.length; i++) {
            num[nums1.length + i] = nums2[i];
        }
        Arrays.sort(num);
        System.out.println(num.length == m + n);
        if (num.length == 0) {
            return 0;
        }
        if (num.length % 2 == 0) {
            return (num[num.length / 2] + num[num.length / 2 - 1]) / 2.0;
        } else {
            return num[num.length / 2];
        }

方法二

简单粗暴，先将两个数组合并，两个有序数组的合并也是归并排序中的一部分。然后根据奇数，还是偶数，返回中位数。

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

            return nums2[n / 2];
        }
    }
    if (n == 0) {
        if (m % 2 == 0) {
            return (nums1[m / 2 - 1] + nums1[m / 2]) / 2.0;
        } else {
            return nums1[m / 2];
        }
    }

    int count = 0;
    int i = 0, j = 0;
    while (count != (m + n)) {
        if (i == m) {
            while (j != n) {
                nums[count++] = nums2[j++];
            }
            break;
        }
        if (j == n) {
            while (i != m) {
                nums[count++] = nums1[i++];
            }
            break;
        }

        if (nums1[i] < nums2[j]) {
            nums[count++] = nums1[i++];
        } else {
            nums[count++] = nums2[j++];
        }
    }

    if (count % 2 == 0) {
        return (nums[count / 2 - 1] + nums[count / 2]) / 2.0;
    } else {
        return nums[count / 2];
    }
}

在归并是不用归并完 比到中位数的位置就停止 不过时间还是O(m+n)

public double findMedianSortedArrays(int[] A, int[] B) {
    int m = A.length;
    int n = B.length;
    int len = m + n;
    int left = -1, right = -1;
    int aStart = 0, bStart = 0;
    for (int i = 0; i <= len / 2; i++) {
        left = right;
        if (aStart < m && (bStart >= n || A[aStart] < B[bStart])) {
            right = A[aStart++];
        } else {
            right = B[bStart++];
        }
    }
    if ((len & 1) == 0)
        return (left + right) / 2.0;
    else
        return right;
}

方法三

找中位数，就是删除（逻辑删除）中位数位置前面的数字，用递归删除
时间复杂度：O(log(m+n)

//方法三：大佬解法 O(log(m+n))  用递归
    //用递归函数把小的那个对应的数组的数字排除，将两个新数组进入递归，并且 k 要减去排除的数字的个数
    //时间复杂度：每进行一次循环，我们就减少 k/2 个元素，所以时间复杂度是 O(log(k)，而 k=(m+n)/2，所以最终的复杂也就是 O(log(m+n）)。
    //空间复杂度：虽然我们用到了递归，但是可以看到这个递归属于尾递归，所以编译器不需要不停地堆栈，所以空间复杂度为 O(1)。
    public double findMedianSortedArrays3(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int m = nums2.length;

        int left = (n + m + 1) / 2;
        int right = (n + m + 2) / 2;

        //将偶数和奇数的情况合并，如果是奇数，会求两次同样的k。
        return (getKth(nums1, 0, n - 1, nums2, 0, m - 1, left) + getKth(nums1, 0, n - 1, nums2, 0, m - 1, right)) / 2.0;

    }

    //递归函数  用于找到返回两个数组中第k个小的值
    // 我们一次遍历就相当于去掉不可能是中位数的一个值，也就是一个一个排除。由于数列是有序的，其实我们完全可以一半儿一半儿的排除。
    //假设我们要找第 k 小数，我们可以每次循环排除掉 k/2 个数。
    //递归出口就是当 k=1 或者其中一个数字长度是 0 了
    private 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;

        //如果len1大，则交换两个数组，让 len1 的长度始终小于 len2，这样就能保证如果有数组空了，一定是 len1
        if (len1 > len2) return getKth(nums2, start2, end2, nums1, start1, end1, k);

        //递归出口 如果一个数组空了，不用递归了，直接返回另一个数组中k指的坐标
        if (len1 == 0) return nums2[start2 + k - 1];

        //递归出口 k=1 就是只需找到最小的  比较一下两个数组的指针即可
        if (k == 1) return Math.min(nums1[start1], nums2[start2]);

        //一半儿一半儿的排除小的数
        //为了防止数组长度小于 k/2，所以每次比较 min(k/2，len(数组)) 对应的数字
        int i = start1 + Math.min(len1, k / 2) - 1;
        int j = start2 + Math.min(len2, k / 2) - 1;

        //把小的那个对应的数组的数字排除，将两个新数组进入递归，并且 k 要减去排除的数字的个数
        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));
        }


    }

方法四

根据中位数的定义，对数组进行切分。

时间复杂度：
我们对较短的数组进行了二分查找，所以时间复杂度是 O(log（min（m，n））

空间复杂度：只有一些固定的变量，和数组长度无关，所以空间复杂度是 O(1)

    //解法四
    //时间复杂度：我们对较短的数组进行了二分查找，所以时间复杂度是 O(log（min（m，n））
    //
    //空间复杂度：只有一些固定的变量，和数组长度无关，所以空间复杂度是 O(1)。

    public double findMedianSortedArrays4(int[] A, int[] B) {
        int m = A.length;
        int n = B.length;
        if (m > n) {
            return findMedianSortedArrays4(B, A);    //保证m<=n
        }
        //找到i的位置
        int iMin = 0, iMax = m;
        //最后一个问题，增加 i 的方式。当然用二分了。初始化 i 为中间的值，然后减半找中间的，减半找中间的，减半找中间的直到答案。
        while (iMin <= iMax) {
            int i = (iMax + iMin) / 2;
            int j = (m + n + 1) / 2 - i;
            if (j!=0&&i!=m&&B[j-1]>A[i]){  //i 需要增加
                iMin = i+1;
            }
            else if (i!=0&&j!=n&&A[i-1]>B[j]){  // i 需要减小
                iMax = i-1;
            }

            // 达到要求（左边最大小于右边最小），并且将边界条件列出来单独考虑
            else {
                int maxLeft = 0;  // 左半部分最大值
                if (i==0) {
                    maxLeft=B[j-1];
                }
                else if (j==0){
                    maxLeft=A[i-1];
                }
                else {
                    maxLeft=Math.max(A[i-1],B[j-1]);
                }
                if ((m+n)%2==1) return maxLeft; // 奇数的话 不用考虑左半部分

                //求右半部分的最小值
                int minRight = 0;
                if (i==m){
                    minRight=B[j];
                }
                else if (j==n){
                    minRight=A[i];
                }
                else {
                    minRight = Math.min(A[i],B[j]);
                }
                //如果是偶数的话就返回结果
                return (maxLeft+minRight)/2.0;
            }
        }
        return 0.0;

    }

总结

1. 思路有，但是代码不一定能实现或者写的优雅，还要考虑数组边界（特殊）情况。
2. 想要log级别的复杂度，就要考虑二分查找、递归的方法，递归理解起来相对比较复杂，但是代码确实简单优雅。
3. 算法思考起来，应该先易后难，一开始不一定是最优解，先实现出来，再考虑优化迭代。比如第一二个方法，归并排序。
4. 统一的美;对不同情况进行分类讨论，但是考虑是否可以进行合并，不同情况用同一个方式（代码）实现。比如对数组大小奇偶数不同，求得中位数位置不同，是否可以将两种情况合并，比如方法三。