Leetcode——4. Median of Two Sorted Arrays

1. 概述

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

Example 1:

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

The median is 2.0

Example 2:

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

The median is (2 + 3)/2 = 2.5

原题中的描述如上所说， 就是给定两个数组，求取数组中的中位数。想到的方案便是整合两个数组==》排序==》求中位数

2. 编码

2.1 方法1

这个方法直接采用将两个vector合并，之后重新排序，之后求取中位数

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2)
    {
        int len1(nums1.size()), len2(nums2.size()); //得到数组1，2的长度
        if(len1+len2 == 0) return 0;
        if(len1+len2 == 1) return len1==1?nums1[0]:nums2[0];
        if(len1==0 && 0!=len2)
        {
            int half_pos(len2/2);
            if(len2%2 == 0) 
            {
                return (double)(nums2[half_pos-1]+nums2[half_pos])/2.0;
            }
            else
                return (double)nums2[half_pos];
        }
        else if(len1!=0 && 0==len2)
        {
            int half_pos(len1/2);
            if(len1%2 == 0) 
            {
                return (double)(nums1[half_pos-1]+nums1[half_pos])/2.0;
            }
            else
                return (double)nums1[half_pos];
        }
        int pos(0); //记录移动的位置
        vector<int> temp;
        
        //方法1
        temp = nums1;
        temp.insert(temp.end(), nums2.begin(), nums2.end());
        sort(temp.begin(), temp.end());    //由小到大排列        
        
        if(temp.size()%2 == 0) 
        {
            int half_pos(temp.size()/2);
            return (double)(temp[half_pos-1]+temp[half_pos])/2.0;
        }
        else
            return (double)temp[temp.size()/2];
        
    }
};

性能：

2.2 方法2

方法2采用的方式就是直接比较数组中的元素，再插入到新的数组中去，得到一个新的数组，之后求取中位数。

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2)
    {
        int len1(nums1.size()), len2(nums2.size()); //得到数组1，2的长度
        if(len1+len2 == 0) return 0;
        if(len1+len2 == 1) return len1==1?nums1[0]:nums2[0];
        if(len1==0 && 0!=len2)
        {
            int half_pos(len2/2);
            if(len2%2 == 0) 
            {
                return (double)(nums2[half_pos-1]+nums2[half_pos])/2.0;
            }
            else
                return (double)nums2[half_pos];
        }
        else if(len1!=0 && 0==len2)
        {
            int half_pos(len1/2);
            if(len1%2 == 0) 
            {
                return (double)(nums1[half_pos-1]+nums1[half_pos])/2.0;
            }
            else
                return (double)nums1[half_pos];
        }
        int pos(0); //记录移动的位置
        vector<int> temp;
        
        //方法2
        if(len1 >= len2)
        {
            int i=0;
            for(i=0; i<len2; i++)
            {
                if(nums2[i] < nums1[pos])
                {
                    while(nums2[i] < nums1[pos])
                    {
                        temp.push_back(nums2[i]);
                        ++i;
                        if(i>=len2) break;
                    }
                    --i;
                    temp.push_back(nums1[pos]);
                    ++pos;
                }   //长度比较小的数组的元素小于了较长数组的元素
                else if(nums2[i] >= nums1[pos])
                {
                    while(nums2[i] >= nums1[pos])
                    {
                        temp.push_back(nums1[pos]);
                        ++pos;
                        if(pos >= len1) break;
                    }   //将较短数组中的元素i插入到新的数组中去
                    temp.push_back(nums2[i]);
                }
                if(pos>=len1) break;
            }
            if(len2<=(i+1) && (pos+1)<=len1)
            {
                for(int k=pos; k<len1; k++)
                    temp.push_back(nums1[k]);
            }  //数组1没走完，数组2走完了
            else if(len2>=(i+1) && (pos+1)>len1)
            {
                for(int k=(i+1); k<len2; k++)
                    temp.push_back(nums2[k]);
            }  //数组1走完了，但是数组2没走完
        }
        else
        {
            int i=0;
            for(i=0; i<len1; i++)
            {
                if(nums1[i] < nums2[pos])
                {
                    while(nums1[i] < nums2[pos])
                    {
                        temp.push_back(nums1[i]);
                        ++i;
                        if(i>=len1) break;
                    }
                    --i;
                    temp.push_back(nums2[pos]);
                    ++pos;
                }   //长度比较小的数组的元素小于了较长数组的元素
                else if(nums1[i] >= nums2[pos])
                {
                    while(nums1[i] >= nums2[pos])
                    {
                        temp.push_back(nums2[pos]);
                        ++pos;
                        if(pos >= len2) break;
                    }   //将较短数组中的元素i插入到新的数组中去
                    temp.push_back(nums1[i]);
                }
                if(pos>=len2) break;
            }
            if(len1<=(i+1) && (pos+1)<=len2)
            {
                for(int k=pos; k<len2; k++)
                    temp.push_back(nums2[k]);
            }  //数组1没走完，数组2走完了
            else if(len1>=(i+1) && (pos+1)>=len2)
            {
                for(int k=(i+1); k<len1; k++)
                    temp.push_back(nums1[k]);
            }  //数组1走完了，但是数组2没走完
        }      
        
        if(temp.size()%2 == 0) 
        {
            int half_pos(temp.size()/2);
            return (double)(temp[half_pos-1]+temp[half_pos])/2.0;
        }
        else
            return (double)temp[temp.size()/2];
        
    }
};

性能：