LeetCode刷题记录4-寻找两个有序数组的中位数

题目

给定两个大小为 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

扩展数组法，时间O(n + m)，空间O(1)

当然这个解法没有达到LeetCode的时间复杂度要求。。。这也是本人能想出的最好的方法了。。。
扩充nums1，将nums2填充到nums1部分（通过比较依次填充）。
步骤如下：

nums1 = [1, 2]
nums2 = [3, 4]

1. 扩充nums1
nums1 = [1, 2, 0, 0]
2. 反向比较nums1和nums2
3. 比较nums1[1]和nums2[1]，由于nums1[1] < nums2[1]，将nums2[1]填充到nums1[i + j + 1](也就是nums1[3])位置
nums1 = [1, 2, 0, 4]
4. 重复3步骤最终
nums1 = [1, 2, 3, 4]
nums2 = [3, 4]
5. 取nums1中位数即可

示例代码：

double findMedianSortedArrays(vector<int> nums1, vector<int> nums2) {
    if(nums1.empty() && nums2.empty())
    { 
        return 0.0;
    }
    int i = nums1.size() - 1;
    int j = nums2.size() - 1;
    nums1.resize(nums1.size() + nums2.size());

    while (i >= 0 && j >= 0)
    {
        if (j >= 0 && nums1[i] > nums2[j])
        {
            nums1[i + j + 1] = nums1[i];
            --i;
        }

        if (i >= 0 && nums1[i] <= nums2[j])
        {
            nums1[i + j + 1] = nums2[j];
            --j;
        }
    }
    while(i >= 0)
    {
        nums1[i + j + 1] = nums1[i];
        --i;
    }
    while (j >= 0)
    {
        nums1[i + j + 1] = nums2[j];
        --j;
    }

    int len = nums1.size();
    if (len % 2 == 0)
    {
        return double(nums1[len >> 1] + nums1[(len >> 1) - 1]) / 2;
    }
    else
    {
        return nums1[len >> 1];
    }
}

LeetCode运行效果也非常不错！

官方解法log(m+n)，空间O(1)

看了N遍才看懂！！！
解题方法如下：
为了解决这个问题，我们需要理解“中位数的作用是什么”。在统计中，中位数被用来：

将一个集合划分为两个长度相等的子集，其中一个子集中的元素总是大于另一个子集中的元素。

如果理解了中位数的划分作用，我们就很接近答案了。

首先，让我们在任一位置 i 将A划分成两个部分：

          left_A             |        right_A
    A[0], A[1], ..., A[i-1]  |  A[i], A[i+1], ..., A[m-1]

由于A中有 m 个元素， 所以我们有 m+1种划分的方法（i =0∼m）。

我们知道：

len(left_A)=i,len(right_A)=m−i.

注意：当 i = 0i=0 时，\text{left\_A}left_A 为空集， 而当 i = mi=m 时, \text{right\_A}right_A 为空集。

采用同样的方式，我们在任一位置j将B划分成两个部分：

          left_B             |        right_B
    B[0], B[1], ..., B[j-1]  |  B[j], B[j+1], ..., B[n-1]

将 left_A 和 left_B 放入一个集合，并将 right_A 和 right_B 放入另一个集合。 再把这两个新的集合分别命名为 left_part 和 right_part：

          left_part          |        right_part
    A[0], A[1], ..., A[i-1]  |  A[i], A[i+1], ..., A[m-1]
    B[0], B[1], ..., B[j-1]  |  B[j], B[j+1], ..., B[n-1]

如果我们可以确认：

1. len(left_part) = len(right_part)
2. max(left_part) ≤ min(right_part)

那么，我们已经将 {A,B} 中的所有元素划分为相同长度的两个部分，且其中一部分中的元素总是大于另一部分中的元素。那么：

要确保这两个条件，我们只需要保证：




示例代码如下：

double findMedianSortedArrays3(vector<int> nums1, vector<int> nums2) {
    int m = nums1.size();
    int n = nums2.size();
    if (m > n)      //保证m < n
    {
        std::swap(nums1, nums2);
        int tmp = m; m = n; n = tmp;
    }
    int iMin = 0;
    int iMax = m;
    int mid = (m + n + 1) / 2;
    while (iMin <= iMax)
    {
        int i = (iMin + iMax) / 2;
        int j = mid - i;
        if (i < iMax && nums2[j - 1] > nums1[i])
        {
            iMin = i + 1;
        }
        else if (i > iMin && nums1[i - 1] > nums2[j])
        {
            iMax = i - 1;
        }
        //i is prefect
        else
        {
            int maxLeft = 0;
            if (i == 0) {
                maxLeft = nums2[j - 1];
            }
            else if (j == 0){
                maxLeft = nums1[i - 1];
            }
            else{
                maxLeft = std::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 = std::min(nums2[j], nums1[i]);
            }
            return (maxLeft + minRight) / 2.0;
        }
    }
    return 0.0;
}

结果非常棒！！！