leetcode代码解析4

4.题目：求两个排序数组nums1和nums2的中位数

方法：设两个数组长度分别为m,n,两个数组中小于或等于中位数的个数之和half =(m+n+1)/2,假设第half位数位于nums1的第i位,或nums2的第j位，其中i+j=half，则满足nums1的i+1位和nums2的j+1位均大于half位，通过令j = half-i来求得i,通过nums1的第i位和nums2的第j位相比较，更大的那个便是第half位，求得half之后再根据m+n的奇偶性求得中位数

c++代码：

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size();
        if (m > n) return findMedianSortedArrays(nums2, nums1);
        int i, j, imin = 0, imax = m, half = (m + n + 1) / 2;
        while (imin <= imax) {
            i = (imin+imax)/2;
            j = half - i;
            if (i > 0 && j < n && nums1[i - 1] > nums2[j]) imax = i - 1;
            else if (j > 0 && i < m && nums2[j - 1] > nums1[i]) imin = i + 1;
            else break;
        }
        int num1;
        if (!i) num1 = nums2[j - 1];
        else if (!j) num1 = nums1[i - 1]; 
        else num1 = max(nums1[i - 1], nums2[j - 1]);
        if ((m + n) & 1) return num1;
        int num2;
        if (i == m) num2 = nums2[j];
        else if (j == n) num2 = nums1[i];
        else num2 = min(nums1[i], nums2[j]);
        return (num1 + num2) / 2.0;
    }
};

python代码：

class Solution(object):
    def findMedianSortedArrays(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: float
        """
        A, B, m, n = nums1, nums2, len(nums1), len(nums2)
        if m > n: A, B, m, n = B, A, n, m
        if n == 0: raise ValueError
        
        imin, imax, half_len = 0, m, (m+n+1)/2
        
        while imin <= imax:
            i = (imin + imax) / 2
            j = half_len - i
            
            if i < m and B[j-1] > A[i]:
                imin = i+1
            elif i > 0  and A[i-1] > B[j]:
                imax = i-1
            else:
                if i == 0: max_of_left = B[j-1]
                elif j == 0: max_of_left = A[i-1]
                else: max_of_left = max(B[j-1], A[i-1])
                
                if (m+n)%2 == 1:
                    return max_of_left
                
                if i == m: min_of_right = B[j]
                elif j == n: min_of_right = A[i]
                else: min_of_right = min(B[j], A[i])
                
                return (max_of_left+min_of_right)/2.0