4. Median of Two Sorted Arrays

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)).

题解:对于这道题自己的做法，自己不是很满意，虽然accept，但是时间不是很满意；显然还有更优解，只是自己还想不出来！我的思路是首先进行一个循环，循环的大小是Min（（m + n）/2 + 1，m, n）,因为求得是中值且两个数组已排序，所以，我们最多进行一半的遍历，既可以得到一个有序的数组sort，它的大小是Min（（m + n）/2 + 1，m, n），然后接下来呢？

       自己也产生了矛盾是就此停止遍历，分析现有的sort和未放入sort的nums1和nums2的值之间的关系得到结果；还是继续遍历，直到sort的大小等于（m + n）/2 + 1，直接根据情况输出sort中尾部的值！自己的感觉是前者的时间更短；但是实际情况却不是如此，首先我们看看后者继续遍历，代码如下：

double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
	int m = nums1.size();
	int n = nums2.size();

	int i, j, k;
	i = j = k = 0;
	int count = (m + n) / 2 + 1;
	double sort[count];
	while (i < count && j < m && k < n) {
		if (nums1[j] >= nums2[k]) {
			sort[i] = nums2[k];
			k++;i++;
			continue;
		}

		if (nums1[j]<nums2[k]) {
			sort[i] = nums1[j];
			j++;i++;
			continue;
		}
	}
    if(j == m){
        while(i < count){
            sort[i] = nums2[k];
            i++;k++;
        }
    }
    if(k == n){
        while(i < count){
            sort[i] = nums1[j];
            i++;j++;
        }
    }
	if ((m + n) % 2 == 0)
		return (sort[i - 1] + sort[i - 2]) / 2;

	return sort[i - 1];
}

得到的结果如：

再来看看第二种情况：分析sort和剩下的nums1和nums2,三者之间的情况，显然是复杂的，所以，最后代码写出来，自己都觉得难看如下：

double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
	int m = nums1.size();
	int n = nums2.size();

	int i, j, k;
	i = j = k = 0;
	int count = (m + n) / 2 + 1;
	double sort[count];
	while (i < count && j < m && k < n) {
		if (nums1[j] >= nums2[k]) {
			sort[i] = nums2[k];
			k++;i++;
			continue;
		}

		if (nums1[j]<nums2[k]) {
			sort[i] = nums1[j];
			j++;i++;
			continue;
		}
	}
    if(i == count){
        if((m + n)%2 == 0){
          return (sort[count-1]+sort[count-2])/2;
        }else{
          return sort[count-1];
        }
    }
    if(j==m){
        double pt1,pt2;
        if((m + n) % 2 == 0){
           if( (m+n)/2 < i){
               pt1 = sort[(m+n)/2];
           }else{
               pt1 = nums2[(n-m)/2];
           }
           
           if((m+n)/2-1 < i){
               pt2 = sort[(m+n)/2-1];
           }else{
               pt2 = nums2[(n-m)/2-1];
           }
           return (pt1+pt2)/2;
        }else{
            return nums2[(n-m)/2];
        }
    }
    if(k==n){
        double pt1,pt2;
        if((m + n) % 2 == 0){
           if( (m+n)/2 < i){
               pt1 = sort[(m+n)/2];
           }else{
               pt1 = nums1[(m-n)/2];
           }
           
           if((m+n)/2-1 < i){
               pt2 = sort[(m+n)/2-1];
           }else{
               pt2 = nums1[(m-n)/2-1];
           }
           return (pt1+pt2)/2;
        }else{
           return nums1[(m-n)/2];
        }
    }
}

得到的结果如下：

结果就是这样，两者解法的结果都不是很理想，但是反而继续遍历的结果更好，这出乎了我的意料！这是一道很有意思的题目，如果你有更好的解法也可以留言！