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

通过万岁！！！

• 题目：给你两个有序的数组，然后找到这两个数组的中位数。但是时间复杂度度要求小于o(log(m+n))
• 思路：最简单的方式当然就是合并数组，然后排序。但是这个题是两个数组，我们可以考虑以下双指针的形式。
  • 方式1：最简单的方式，数组合并然后数组排序（Arrays.sort）。这种的时间复杂度应该是在排序上，时间复杂度为快速排序的时间复杂度。空间复杂度的话就是o(m+n)。
  • 方式2：采用双指针遍历数组。我们可以遍历数组，然后将他们小的放到一个数组中，然后在这个数组中拿到中位数这一个的时间复杂度就变成了o(m+n)。空间复杂度还是o(m+n)。
    • 升级：通过方式2我们可以发现，我们不需要遍历到末尾，我们遍历到中间位置基本就知道答案了。也就是两个指针指向的下标和在中位数的位置的时候就可以了，这里时间和空间复杂度都可以降低为o((m+n)/2)。
    • 再次升级：我们可以发现，其实存储的数组我们只需要两个变量保存就行了。因为中位数最多就是两个数求和除2。这样我们将空间复杂度降低到了o(1)，时间复杂度为o((m+n)/2)。
• 技巧：我们使用双指针进行遍历，这样将时间复杂度进行降低。不需要进行排序，并且我们根据中位数和所给数组将时间复杂度再次降低。

伪代码——方式1

创建新数组，长度为两个数组的和
数组进行复制
数组进行排序
根据两数组长度和计算中位数，并返回

java代码

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int nums12[] = new int[nums1.length + nums2.length];
        System.arraycopy(nums1, 0, nums12, 0, nums1.length);
        System.arraycopy(nums2, 0, nums12, nums1.length, nums2.length);
        Arrays.sort(nums12);
        if (nums12.length % 2 == 0)
            return (nums12[nums12.length / 2 - 1] + nums12[nums12.length / 2]) / 2.0;
        else return nums12[nums12.length / 2];
    }
}

伪代码——方式2——升级：

有一个数组是空，计算另外一个数组的中位数并返回
中位数下标mid
定义两个指针l1和l2
定义meger数组，长度为mid+1
while(还没找到mid){
    如果nums1[l1]>nums2[l2]
        将nums2[l2]的值给merger[l1+l2]
            判断l2还能不能++，放置越界，能就++
            不能就说明nums2遍历遍历完了，然后while将nums1的值给merger，直到merger满了。
    否则
        将nums1[l1]的值给merger[l1+l2]
        判断l1还能不能++，放置越界，能就++
        不能就说明nums1遍历遍历完了，然后while将nums2的值给merger，直到merger满了。
最后判断是奇数的话，返回merger[mid]，偶数返回(merger[mid-1]+merger[mid])/2;

java代码

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int len1 = nums1.length, len2 = nums2.length;
        if (len1 == 0)
            if (len2 % 2 == 1) return nums2[len2 / 2];
            else return (nums2[len2 / 2] + nums2[len2 / 2 - 1]) / 2.0;
        if (len2 == 0)
            if (len1 % 2 == 1) return nums1[len1 / 2];
            else return (nums1[len1 / 2] + nums1[len1 / 2 - 1]) / 2.0;
        if (len1 == 1 && len2 == 1)
            return (nums1[0] + nums2[0]) / 2.0;
        int l1 = 0, l2 = 0;
        boolean single = (nums1.length + nums2.length) % 2 == 1 ? true : false;
        int mid = (len1 + len2) / 2;
        int merger[] = new int[mid + 1];
        while (l1 + l2 <= mid) {
            if (nums1[l1] > nums2[l2]) {
                merger[l1 + l2] = nums2[l2];
                if (l2 < len2 - 1)
                    l2++;
                else {
                    while (l1 + l2 < mid) {
                        merger[l1 + l2 + 1] = nums1[l1++];
                    }
                    break;
                }
            } else {
                merger[l1 + l2] = nums1[l1];
                if (l1 < len1 - 1)
                    l1++;
                else {
                    while (l1 + l2 < mid) {
                        merger[l1 + l2 + 1] = nums2[l2++];
                    }
                    break;
                }
            }
        }   
        return single ? merger[mid] : (merger[mid] + merger[mid - 1]) / 2.0;
    }
}

伪代码——方式2——再次升级：

上面的升级版的时候数组其实我们只需要最后两位。
我们定一个a和b，然后每次给数组复制的时候
a=b;
b=新的值;
这样就再次降低了空间复杂度

java代码

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int len1 = nums1.length, len2 = nums2.length;
        if (len1 == 0)
            if (len2 % 2 == 1) return nums2[len2 / 2];
            else return (nums2[len2 / 2] + nums2[len2 / 2 - 1]) / 2.0;
        if (len2 == 0)
            if (len1 % 2 == 1) return nums1[len1 / 2];
            else return (nums1[len1 / 2] + nums1[len1 / 2 - 1]) / 2.0;
        if (len1 == 1 && len2 == 1)
            return (nums1[0] + nums2[0]) / 2.0;
        int l1 = 0, l2 = 0;
        int mid = (len1 + len2) / 2;
        int a = 0, b = 0;// 中位数，有可能是两个，如果是一个就是用后面这个
        while (l1 + l2 <= mid) {
            if (nums1[l1] > nums2[l2]) {
                a = b;
                b = nums2[l2];
                if (l2 < len2 - 1)
                    l2++;
                else {
                    while (l1 + l2 < mid) {
                        a = b;
                        b = nums1[l1++];
                    }
                    break;
                }
            } else {
                a = b;
                b = nums1[l1];
                if (l1 < len1 - 1)
                    l1++;
                else {
                    while (l1 + l2 < mid) {
                        a = b;
                        b = nums2[l2++];
                    }
                    break;
                }
            }
        }
        return ((len1 + len2) % 2 == 1 ? true : false) ? b : (a + b) / 2.0;
    }
}

• 总结：这个题其实不难，主要是理清楚思路，如果没有思路，就先用最简单的方式试一下，毕竟通过万岁么！！！至于思路的话，看到这种两个啥东西的，先考虑以下双指针，能不能遍历一遍就得到结果，然后先不要考虑空间复杂度，一步一步来。如果直接想最后一种的话，确实比较困难。