寻找两个有序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。请你找出这两个有序数组的中位数，而且要求算法的时间复杂度为 O(log(m + n))。你能够假设 nums1 和 nums2 不会同时为空。（LeetCode题目）

示例 1:

nums1 = [1, 3]
nums2 = [2]
则中位数是 2.0

示例 2:

nums1 = [1, 2]
nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5

方法一：子集划分

为了解决这个问题，咱们须要理解 “中位数的做用是什么”。在统计中，中位数被用来：将一个集合划分为两个长度相等的子集，其中一个子集中的元素老是大于另外一个子集中的元素。
若是理解了中位数的划分做用，咱们就很接近答案了。

首先，让咱们在任一位置 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=0 时，left_A为空集， 而当 i=m时, 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]

若是咱们能够确认：

len(left_part)=len(right_part)
    max⁡(left_part)≤min⁡(right_part)

那么，咱们已经将 {A,B}中的全部元素划分为相同长度的两个部分，且其中一部分中的元素老是大于另外一部分中的元素。那么：median=(max(left_part)+min(right_part)​)/2

要确保这两个条件，咱们只须要保证：

i+j=m−i+n−j（或：m−i+n−j+1,即m+n为奇数时，把多的一个放left_part）
    若是 n≥m只须要使  i=0∼m, j=(m+n+1)/2−i(由于j是整型，因此m+n为奇数或偶数时，j都是(m+n+1)/2,如m+n=3,j=2;m+n=4,j=2)
    B[j−1]≤A[i] 以及 A[i−1]≤B[j]

ps.1 为了简化分析，假设 A[i−1],B[j−1],A[i],B[j]老是存在，哪怕出现 i=0，i=m，j=0或是 j=n这样的临界条件。咱们将在最后讨论如何处理这些临界值。

ps.2 为何 n≥m？因为0≤i≤m且 j=(m+n+1)/2−i，咱们必须确保 j不是负数。若是 n<m，那么 j 将多是负数，而这会形成错误的答案。

因此，咱们须要作的是：

在 [0，m]中搜索并找到目标对象 i，以使：

B[j−1]≤A[i]且 A[i−1]≤B[j], 其中 j=(m+n+1)/2−i

接着，咱们能够按照如下步骤来进行二叉树搜索：

设 imin=0，imax=m, 而后开始在 [imin,imax]中进行搜索。

令 i=(imin+imax2)/2​， j=(m+n+1)/2−i

如今咱们有 len(left_part)=len(right_part)。 并且咱们只会遇到三种状况：

    B[j−1]≤A[i]且 A[i−1]≤B[j]：
    这意味着咱们找到了目标对象 i，因此能够中止搜索。

    B[j−1]>A[i]：
    这意味着 A[i]过小，咱们必须调整 i 以使 B[j−1]≤A[i]。
    咱们能够增大 i 吗？
          是的，由于当 i 被增大的时候，j 就会被减少。
          所以 B[j−1]会减少，而 A[i]会增大，那么 B[j−1]≤A[i]就可能被知足。
    咱们能够减少 i 吗？
          不行，由于当 i 被减少的时候，j 就会被增大。
          所以 B[j−1]会增大，而 A[i] 会减少，那么 B[j−1]≤A[i]就可能不知足。
    因此咱们必须增大 i。也就是说，咱们必须将搜索范围调整为 [i+1,imax]。

    A[i−1]>B[j]：
    这意味着 A[i−1] 太大，咱们必须减少 i以使 A[i−1]≤B[j]。
    也就是说，咱们必须将搜索范围调整为 [imin,i−1]。

当找到目标对象 i 时，中位数为：

max⁡(A[i−1],B[j−1]), 当 m+n为奇数时

max⁡(A[i−1],B[j−1])+min⁡(A[i],B[j])/2, 当 m+n为偶数时

如今，让咱们来考虑这些临界值 i=0,i=m,j=0,j=n，此时 A[i−1],B[j−1],A[i],B[j]可能不存在。
其实这种状况比你想象的要容易得多。

咱们须要作的是确保 max(left_part)≤min(right_part)。 所以，若是 i和 j 不是临界值（这意味着 A[i−1],B[j−1],A[i],B[j]所有存在）, 那么咱们必须同时检查 B[j−1]≤A[i]以及 A[i−1]≤B[j]是否成立。
可是若是 A[i−1],B[j−1],A[i],B[j]中部分不存在，那么咱们只须要检查这两个条件中的一个（或不须要检查）。
举个例子，若是 i=0那么 A[i−1]不存在，咱们就不须要检查 A[i−1]≤B[j]是否成立。
因此，咱们须要作的是：

在 [0，m]中搜索并找到目标对象 i，以使：

(j=0 or i=m or B[j−1]≤A[i])或是
(i=0 or j=n or A[i−1]≤B[j]), 其中 j=(m+n+1)/2−i

在循环搜索中，咱们只会遇到三种状况：

(j=0 or i=m or B[j−1]≤A[i])或是 (i=0 or j=n or A[i−1]≤B[j])，这意味着 i 是完美的，咱们能够中止搜索。
    j>0 and i<m and B[j−1]>A[i] 这意味着 i 过小，咱们必须增大它。
    i>0 and j<n and A[i−1]>B[j] 这意味着 i 太大，咱们必须减少它。

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size();
        if (m > n) { //确保n>=m
            vector<int> temp = nums1;
            nums1 = nums2, nums2 = temp;
            m = nums1.size(), n = nums2.size();
        }
        int imin = 0, imax = m,half=(m+n+1)/2;
        int i = (imin + imax) / 2, j = half - i;
        while (imax>=imin)
        {
            i = (imin + imax) / 2, j = half - i;
            if (j > 0 && i<m && nums2[j - 1]>nums1[i])
                imin = i + 1;
            else if (i > 0 && j<n && nums1[i - 1]>nums2[j])
                imax = i - 1;
            else
            {
                int maxleft, minright;
                if (i == 0)maxleft = nums2[j - 1];
                else if (j == 0)maxleft = nums1[i - 1];
                else
                {
                    maxleft = nums2[j - 1] > nums1[i - 1] ? nums2[j - 1] : nums1[i - 1];
                }

                if ((m + n) % 2)
                    return maxleft * 1.0;

                if (i == m)minright = nums2[j];
                else if (j == n)minright = nums1[i];
                else 
                {
                    minright = nums2[j] < nums1[i] ? nums2[j] : nums1[i];
                }

                return (maxleft + minright) * 1.0 / 2;
            }
        }
        return -1;
            
    }
};

方法二：第K小值

题目是求中位数，其实就是求第 k 小数的一种特殊状况。
因为数列是有序的，其实咱们彻底能够一半一半的排除。假设咱们要找第 k 小数，咱们能够每次循环排除掉 k/2 个数。看下边一个例子。
假设咱们要找第 7 小的数字。

咱们比较两个数组的第 k/2 个数字，若是 k 是奇数，向下取整。也就是比较第 3 个数字，上边数组中的 4 和下边数组中的 3，若是哪一个小，就代表该数组的前 k/2 个数字都不是第 k 小数字，因此能够排除。也就是 1，2，3这三个数字不多是第7 小的数字，咱们能够把它排除掉。将 1,3,4,9和 4,5,6,7,8,9,10 两个数组做为新的数组进行比较。

更通常的状况 A[1] ，A[2] ，A[3]，A[k/2] ... ，B[1]，B[2]，B[3]，B[k/2] ... ，若是 A[k/2]<B[k/2] ，那么A[1]，A[2]，A[3]，A[k/2]都不多是第 k 小的数字。

橙色的部分表示已经去掉的数字。

因为咱们已经排除掉了 3 个数字，就是这 3 个数字必定在最前边，因此在两个新数组中，咱们只须要找第 7 - 3 = 4 小的数字就能够了，也就是 k = 4。此时两个数组，比较第 2 个数字，3 < 5，因此咱们能够把小的那个数组中的 1 ，3 排除掉了。

咱们又排除掉 2 个数字，因此如今找第 4 - 2 = 2 小的数字就能够了。此时比较两个数组中的第 k / 2 = 1 个数，4 == 4，怎么办呢？因为两个数相等，因此咱们不管去掉哪一个数组中的都行，由于去掉 1 个总会保留 1 个的，因此没有影响。为了统一，咱们就假设 4 > 4 吧，因此此时将下边的 4 去掉。

因为又去掉 1 个数字，此时咱们要找第 1 小的数字，因此只需判断两个数组中第一个数字哪一个小就能够了，也就是 4。

因此第 7 小的数字是 4。

咱们每次都是取 k/2 的数进行比较，有时候可能会遇到数组长度小于 k/2的时候。

此时 k / 2 等于 3，而上边的数组长度是 2，咱们此时将箭头指向它的末尾就能够了。这样的话，因为 2 < 3，因此就会致使上边的数组 1，2 都被排除。形成下边的状况。

因为 2 个元素被排除，因此此时 k = 5，又因为上边的数组已经空了，咱们只须要返回下边的数组的第 5 个数字就能够了。

从上边能够看到，不管是找第奇数个仍是第偶数个数字，对咱们的算法并无影响，并且在算法进行中，k 的值都有可能从奇数变为偶数，最终都会变为 1 或者因为一个数组空了，直接返回结果。

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

class Solution {
public:
    int findK(vector<int>& A1, int s1, int e1, vector<int>& A2, int s2, int e2, int k) {
        int len1 = e1 - s1 + 1, len2 = e2 - s2 + 1;
        if (len1 == 0)return A2[s2 + k - 1]; //因为数组下标从0开始，因此要减1
        if (len2 == 0)return A1[s1 + k - 1];
        if (k == 1)return A1[s1] < A2[s2] ? A1[s1] : A2[s2];
        int m = k / 2;
        int i = len1 < m ? s1 + len1 - 1 : s1 + m - 1;
        int j= len2 < m ? s2 + len2 - 1 : s2 + m - 1;
        if (A1[i] < A2[j])return findK(A1, i+1, e1, A2, s2, e2, k - (i-s1+1));
        else
            return findK(A1, s1, e1, A2, j+1, e2, k -(j-s2+1));
    }
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size();
        int k1 = (m + n + 1) / 2, k2 = (m + n + 2) / 2; //如m+n为3，则k1=2,k2=2;如m+n=4,则k1=2,k2=3。从而使得m+n为奇数和偶数获得的中位数公式统一，即(findk1+findk2)/2
        return (findK(nums1, 0, m - 1, nums2, 0, n - 1, k1) + findK(nums1, 0, m - 1, nums2, 0, n - 1, k2)) * 0.5;
    }
};