GroupBlog

题目：

　　There are two sorted arrays nums1 and nums2 of size m and n respectively. Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

大意：

　　两个已经排序的数组(长度可能不同),求两个数组合并后的中位数,要求时间复杂度是O(log(m+n))

思路：

　　１、先计算数组总长度，如果是奇数则查找数组中第（sum）/ 2元素并返回

2、如果是偶数则计算中间两个的和，再除以二。

3、查找的方法可以用一个循环，按照数组有序合并的思想从两个数组中有序地查找。

4、时间负责度为O((m+n)/2)，未达到O（log（m+n）），意外AC。。。

代码：

class Solution {
public:
    double findMedianSortedArrays(std::vector<int>& nums1, std::vector<int>& nums2) {
        std::vector<int>::size_type sum = nums1.size() + nums2.size(), j = 0, k = 0;
        double result;
        
        if (nums1.size() == 0 && nums2.size() != 0) {
            if (sum % 2 == 0) {
                return (nums2[nums2.size() / 2] + nums2[nums2.size() / 2 - 1]) / 2.0;
            } else {
                return nums2[nums2.size() / 2];
            }
        } else if (nums2.size() == 0 && nums1.size() != 0) {
            if (sum % 2 == 0) {
                return (nums1[nums1.size() / 2] + nums1[nums1.size() / 2 - 1]) / 2.0;
            } else {
                return nums1[nums1.size() / 2];
            }
        }
        
        if (sum % 2 == 0 ) {
            for (int i = 0; i <=  (sum / 2); ++i) {
                if ((j != nums1.size() && nums1[j] < nums2[k]) || k == nums2.size()) {
                    if (i == sum / 2) {
                        result += nums1[j]; ++j;
                    } else {
                        result = nums1[j]; ++j;
                    }
                } else {
                    if (i == sum / 2) {
                        result += nums2[k]; ++k;
                    } else {
                        result = nums2[k]; ++k;
                    }
                }
            }
            result /= 2.0;
        } else {
            for (int i = 0; i <= (sum / 2); ++i) {
                if ((j != nums1.size() && nums1[j] < nums2[k]) || k == nums2.size()) {
                    result = nums1[j]; ++j;
                } else {
                    result = nums2[k]; ++k;
                }
            }
        }
        return result;
    }
};

　　上述思路的时间复杂度是Ｏ(m+n)，所以严格来讲是不符合题目要求的时间复杂度的，所以这个思路需要进行改进。

思路：

　　１、寻找两个数组的中位数可以转化为寻找两个数组中第 k 小的元素。

2、可以将 k 平分成两个部分，然后进行比较，如果a中的a[k / 2 - 1]小于b[k / 2 -1]，则表示a中k / 2 - 1之前的元素不可能是第k小的数。同理，如果a[k / 2 - 1]大于b[k / 2 - 1]，则表示b中k/2-1前的元素不可能是第k小的数。所以就可以直接抛弃不可能部分。

代码：

//LeetCode 中选择C语言执行此程序

//寻找第k小的元素
//最终二分的效果是要么将nums1数组长度分割完,要么将k分割变成1
int findKth(int *nums1, int nums1Size, int *nums2, int nums2Size, int k)
{
    //保证第一个数组的长度小于等于第二个数组,便于以后的查找工作
    if (nums1Size > nums2Size) {
        return findKth(nums2, nums2Size, nums1, nums1Size, k);
    }

    //如果长度较小的数组长度为0,则返回nums2中下标为k-1
    if (nums1Size == 0) {
        return nums2[k - 1];
    }

    //如果k长度为1,则返回两个数组中较小的一个
    if (k == 1) {
        return nums1[0] < nums2[0] ? nums1[0] : nums2[0];
    }
    
    //在两个数组中二分查找第k小的元素
    int a = (k / 2 < nums1Size ? k / 2 : nums1Size), b = k - a;
    
    if (nums1[a - 1] < nums2[b - 1]) {
        return findKth(nums1 + a, nums1Size - a, nums2, nums2Size, k - a); //舍去nums1中a以前的数
    } else if (nums1[a - 1] > nums2[b - 1]) {
        return findKth(nums1, nums1Size, nums2 + b, nums2Size - b, k - b); //舍去nums2中b以前的数
    } else {
        return nums1[a - 1];    //如果相等则直接返回
    }
}


double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size) 
{
    int sum = nums1Size + nums2Size;

    if (sum & 0x01) {
        return findKth(nums1, nums1Size, nums2, nums2Size, sum / 2 + 1);
    } else {
        return (findKth(nums1, nums1Size, nums2, nums2Size, sum / 2 + 1) + findKth(nums1, nums1Size, nums2, nums2Size, sum / 2)) / 2.0;
    }

}