LeetCode 经典】MedianSortedArrays

【LeetCode 经典】MedianSortedArrays

前言

在两个排序数组中寻找中位数。这个题目本质上二分查找 binarySearch 的变种。需要采用跟二分法类似的思路：先确定一个 median，然后根据当前的状态，舍弃一半，在剩下的一半中继续寻找。

median 与奇偶性

这个问题是不能回避的。对于一个排序数组，我们求 median 的时候，其实会根据数组的元素个数分类讨论：如果总数是奇数，就取数组的最中间那个元素，对应的 index = (n + 1) / 2 ，注意，这里其实有一个小细节，即，这里有一个隐含的类型转换：我们把 m.5 转换成了 m 。比如，如果 n = 10，那么得出的 index 应该是 5.5，然后转换成 int 之后，就是 index = 5。如果总数是偶数，那么就取中间两个元素求平均数，也就是：index1 = n / 2; index2 = index1 + 1;。

因此，把问题扩展到 median of two sorted array 的时候，我们依然不能回避奇偶性的问题。

二分查找的体现

在排序数组里面找元素，一般都逃不开二分查找。这相当于充分利用了数组的排序特性。但是，对于两个数组，其实直接二分查找让我们无从下手，因为两个数组之间并没有明确的关系。所以，我们的二分查找只能针对其中一个数组 A，然后看看另一个数组 B 与数组 A 之间有没有什么关系可以找到。
联系到，我们想找数组的中位数。中位数的含义，其实就是找到一个数字，然后让集合中恰好有一半的元素比中位数小，恰好有一半的元素比中位数大。那么把问题拓展到两个数组中之后，我们需要做类似的事情：把两个数组形成的一个大的集合分成两半，一半比中位数小，一半比中位数大。比如，我们通过二分查找，找到了 A 中的下标为 i 的元素，那么，他意味着，A 中有 i 个元素比他小。也就是说，A 对于“小的一半”会贡献 i 个元素。因为我们可以知道，两个数组一共有多少个元素，即 count = len1 + len2，那么我们就能知道，“小的一半”一共有多少个元素，即 leftCount = count / 2，进而我们就能得出 B 中应该有多少个元素参与到“小的一半”。

一些细节

1. 对于 A 数组全员参与和全员不参与两种情况，我们当做特殊情况来处理。在代码中，会通过 end == -1 和 start == len1 来代表。这两种情况，我们需要单独计算 B 对应的下标。
2. 算法中需要保证 A 的元素不能比 B 多，这样可以让 A 无论是全员参与还是全员不参与，B 经过计算后得到的 index 都是处于一个合理的值。所以在函数的开始，会通过 len1 和 len2 的判断来递归一下。

Talk is cheap, show me the code!

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if (nums1 == null || nums1.length == 0) {
            return findMedian(nums2);
        } else if (nums2 == null || nums2.length == 0) {
            return findMedian(nums1);
        }

        if (nums1.length > nums2.length) {
            return findMedianSortedArrays(nums2, nums1);
        }

        int start1 = 0;
        int end1 = nums1.length - 1;

        int len1 = nums1.length;
        int len2 = nums2.length;
        int totalLen = len1 + len2;
        int leftCount = (totalLen + 1) / 2;

        while (start1 <= end1 || end1 == -1 || start1 == len1) {

            int mid1 = (start1 + end1) >>> 1;
            if (end1 == -1) {
                mid1 = -1;
            } else if (start1 == len1) {
                mid1 = len1;
            }
            int mid2 = leftCount - (mid1 + 1) - 1;

            int a1 = getValueSafe(nums1, mid1, Integer.MIN_VALUE);
            int a2 = getValueSafe(nums1, mid1 + 1, Integer.MAX_VALUE);

            int b1 = getValueSafe(nums2, mid2, Integer.MIN_VALUE);
            int b2 = getValueSafe(nums2, mid2 + 1, Integer.MAX_VALUE);

            if (a1 > b2) {
                end1 = mid1 - 1;
            } else if (b1 > a2) {
                start1 = mid1 + 1;
            } else {
                if (totalLen % 2 == 0) {
                    return ((double) Math.max(a1, b1) + (double) Math.min(a2, b2)) / 2;
                } else {
                    return Math.max(a1, b1);
                }
            }
        }
        return 0;
    }

    private double findMedian(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        if (nums.length % 2 == 0) {
            return ((double) (nums[nums.length / 2] + nums[nums.length / 2 - 1])) / 2;
        } else {
            return nums[nums.length / 2];
        }
    }

    private int getValueSafe(int[] nums, int i, int defaultValue) {
        if (i >= 0 && i < nums.length) {
            return nums[i];
        } else {
            return defaultValue;
        }
    }
}