两个有序数组的中位数

第一次写文章，希望大家可以给我一点建议、留言，谢谢。

问题：

leetCode问题：求两个有序数组的中位数，时间复杂度要求 O( log(n+m) )

思路

下面是我自己的一种理解（来源于代码），自认为这种理解比较简单。
1.归并思想
这种算法比较容易理解，只需要计算出前面 （n + m + 1）/ 2 个就行了，不需要多说。不过不符合时间复杂度的要求。
2.二分法 / 折半查找
先说一下中位数，中位的把数组分为两个元素数量相等的两部分，并且左边最大值一定 <= 右边最小值。对于这道题，我们假设找到中位数后，一定会出现下面的情况：

红线分开的两边元素个数相等，并且Max( A[i-1], B[j-1 ]) <= Min(A[i], B[j]); i和j是下标
所以，我们完全可以把这个问题转化成：二分法查找有序数组里符合要求的数。
这个要求就是:
（1）两边元素数量各占一半，即 half = (n + m + 1) / 2; // n 和 m 为两个数组的长度。
（2）Max(A[i-1], B[j-1]) <= Min(A[i], B[j]);

条件（1）很好保证: 即令 j = half - i; 这样问题就变成了，在有序数组A中查找元素A[i], 满足条件（2），这样就是对数组A进行二分查找/折半查找，只是判断条件变了而已。

注意：最后结果有四种特殊情况，即数组A全部在左边，或者数组A全部在右边，或者数组B全部在左边，或者数组B全部在右边。
下面附代码： 亲测LeetCode通过

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        if (m == 0 && n == 0) {
            return 0.0;
        }
        if (m > n) {
            int[] temp = nums1;
            nums1 = nums2;
            nums2 = temp;
            int tmp = m;
            m = n;
            n = tmp;
        }
        int min = 0, max = m;
        int half = (m + n + 1) / 2;
        while (min <= max) {
            int i = (min + max) / 2;
            int j = half - i;
            if (i < max && nums2[j - 1] > nums1[i]) { //最后的i应该在当前i的右边
                min = i + 1;
            } else if (i > min && j < n && nums2[j] < nums1[i - 1]) { //最后的i应该在当前i的左边
                max = i - 1;
            } else {
                int maxLeft = 0;
                if (i == 0) { // 数组A全部在右边
                    maxLeft = nums2[j - 1];
                } else if (j == 0) { // 数组B全部在右边
                    maxLeft = nums1[i - 1];
                } else {
                    maxLeft = Math.max(nums1[i - 1], nums2[j - 1]);
                }
                if ((n + m & 1) == 1) {
                    return maxLeft;
                }
                int minRight = 0;
                if (i == m) {  // 数组A全部在左边
                    minRight = nums2[j];
                } else if (j == n) {   // 数组B全部在左边
                    minRight = nums1[i];
                } else {
                    minRight = Math.min(nums1[i], nums2[j]);
                }
                return (maxLeft + minRight) / 2.0;
            }
        }
        return 0.0;
    }
}

附：代码来源于LeetCode上面，我只是写一下我对代码的理解。
综上：这个算法的时间复杂度为 O（ log(Min(n, m)) ）。
根据以上的思想，也可以求两个有序数组中的前k个数，只要把上面的half变为k就行。即j = k - i;