leetcode刷题记录——4、Median of Two Sorted Arrays

题目：

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例：

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

则中位数是 2.0

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

则中位数是 (2 + 3)/2 = 2.5

初步实现：题目要求的时间复杂度想不出来，答案的时间复杂度也并不是题目要求的，就按自己的想法先实现了一下。使用两个索引值将nums1和nums2排序合并，然后找出中位数。

class Solution(object):
    def findMedianSortedArrays(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: float
        """
        m = len(nums1)
        n = len(nums2)
        nums = []
        m_index = 0
        n_index = 0
        while m_index < m and n_index < n:
            if nums1[m_index] < nums2[n_index]:
                nums.append(nums1[m_index])
                m_index = m_index + 1
            elif nums1[m_index] > nums2[n_index]:
                nums.append(nums2[n_index])
                n_index = n_index + 1
            elif nums1[m_index] == nums2[n_index]:
                nums.append(nums1[m_index])
                nums.append(nums1[m_index])
                m_index = m_index + 1
                n_index = n_index + 1
        if m_index == m:
            nums = nums + nums2[n_index:]
        elif n_index == n:
            nums = nums + nums1[m_index:]
        if (m + n) % 2 == 0:
            return (nums[(m + n) // 2] + nums[(m + n) // 2 - 1]) / 2.0
        else:
            return nums[(m + n) // 2]

复杂度分析：

时间复杂度：，总比较次数应该是m+n。提交后运行时间为124ms。

空间复杂度：，创建了新数组存储m+n个元素。

 

改进：由于是寻找中位数，所以只用合并一半元素即可。

class Solution(object):
    def findMedianSortedArrays(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: float
        """
        m = len(nums1)
        n = len(nums2)
        nums = []
        m_index = 0
        n_index = 0
        while (m_index + n_index) != (m + n) // 2 + 1 and m_index < m and n_index < n:
            if nums1[m_index] < nums2[n_index]:
                nums.append(nums1[m_index])
                m_index = m_index + 1
            elif nums1[m_index] > nums2[n_index]:
                nums.append(nums2[n_index])
                n_index = n_index + 1
            elif nums1[m_index] == nums2[n_index]:
                nums.append(nums1[m_index])
                nums.append(nums1[m_index])
                m_index = m_index + 1
                n_index = n_index + 1
        if m_index == m:
            nums = nums + nums2[n_index: (m + n) // 2 + 1 - m_index]
        if n_index == n:
            nums = nums + nums1[m_index: (m + n) // 2 + 1 - n_index]
        if (m + n) % 2 == 0:
            return (nums[(m + n) // 2] + nums[(m + n) // 2 - 1]) / 2.0
        else:
            return nums[(m + n) // 2]

复杂度分析：

时间复杂度：，总比较次数应该是(m+n) / 2。提交后运行时间为120ms。

空间复杂度：，创建了新数组存储(m+n) / 2个元素。

 

答案的时间复杂度是，与题目不符，但是一个非常牛逼的解法。算法思想很简单，寻找分割索引 i 和 j，i 将 nums1分为左右两部分，j 将nums2分为左右两部分，再将左部分组合，右部分组合，使左部分中元素数量与右部分中元素数量相等，且左部分中元素全部小于右部分元素，则可在左部分元素的末尾和右部分元素的开头轻松找到中位数。根据以上条件，可以得出一些等式，找到 i 即可求得 j，则只需要在一个范围内二分查找满足条件的 i 即可。算法思想简单，但有许多细节需要仔细处理，有兴趣的可以参考答案。

class Solution(object):
    def findMedianSortedArrays(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: float
        """
        m, n = len(nums1), len(nums2)
        if m > n:
            nums1, nums2, m, n = nums2, nums1, n, m

        # 二分查找i
        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 nums2[j - 1] > nums1[i]:
                imin = i + 1
            elif i > 0 and nums1[i - 1] > nums2[j]:
                imax = i - 1
            else:
                if i == 0:
                    max_of_left = nums2[j - 1]
                elif j == 0:
                    max_of_left = nums1[i - 1]
                else:
                    max_of_left = max(nums1[i - 1], nums2[j - 1])
                if (m + n) % 2 == 1:
                    return max_of_left

                if i == m:
                    min_of_right = nums2[j]
                elif j == n:
                    min_of_right = nums1[i]
                else:
                    min_of_right = min(nums1[i], nums2[j])
                return (max_of_left + min_of_right) / 2.0

复杂度分析：

时间复杂度：，对两数组中元素较少的数组进行二分查找。

空间复杂度：，内存恒定。