樸素解法

求中位數一般是用歸併排序，按照類似快排的思想求第k/2大的數。但是由於給定的兩個陣列都是有序的，一般第一眼看到這個問題，最先想到的就是兩個陣列做排序，然後輸出中位數。不得不說leetcode的資料也是仁慈，居然直接就過了……這個思路實在是太簡單了，就不講了，看程式碼就好了。

#include <string>
#include <iostream>
#include <vector>
using namespace std;
/*
    顯然，最簡單的思路就是兩者歸併排序後直接求，得到的答案肯定是對的。
*/
class Solution {
public
 
:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        vector<int> ans;
        unsigned int i = 0,j = 0;
        while(i<nums1.size()&&j<nums2.size())
        {
            if(nums1[i]<=nums2[j])
            {
                ans.
 
push_back(nums1[i]);
                i++;
            }
            else
            {
                ans.push_back(nums2[j]);
                j++;
            }
        }
        while(i<nums1.size())
        {
            ans.push_back(nums1[i]);
            i++;
        }
        while(j<nums2.
 
size())
        {
            ans.push_back(nums2[j]);
            j++;
        }

//        for(unsigned int k = 0 ; k < ans.size();k++)
//        {
//            cout<<ans[k]<<endl;
//        }
        if(ans.size()%2==0)
        {
            return (double)(ans[ans.size()/2-1]+ans[ans.size()/2])/2;
        }
        else
        {
            return ans[ans.size()/2];
        }

    }
};
int main(void)
{
    Solution s;
    vector<int> a;
    vector<int> b;
    a.push_back(1);
    a.push_back(2);
    b.push_back(3);
   // b.push_back(4);
    cout<<s.findMedianSortedArrays(a,b)<<endl;

    return 0;
}

二分法

這個是官方給的標準答案。
由中位數的定義可以推廣出：

• 如果在集合中存在i將集合化為兩個劃分left和right，i為中位數當且僅當len(left(i))=len(right(i))且max(left(i))<=min(right(i))。
• 由此，如果是兩個有序集合，則如果把這兩個有序集合都用上面這種形式來寫的話，如果它們組成的大集合仍然滿足上面的形式，則這兩個劃分所在的分界點就是中位數。問題就轉化到怎麼求集合的劃分上來了。
• 設這兩個劃分點為i,j；陣列A長為n，陣列B長為m，則有$i+j=n-i+m-j$，$B[j−1]\leq A[i] 以及 A[i-1] \leq B[j]$
• 所以問題就轉化為了在[0,m]上搜索i，使得$B[j−1]\leq A[i] 以及 A[i-1] \leq B[j]，其中j=\frac{n+m-2i}{2}$
  標準答案給的是二分的求法，跟我想到的也一樣，不過我沒寫出來，直接用它的吧。

def median(A, B):
    m, n = len(A), len(B)
    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]:
            # i is too small, must increase it
            imin = i + 1
        elif i > 0 and A[i-1] > B[j]:
            # i is too big, must decrease it
            imax = i - 1
        else:
            # i is perfect

            if i == 0: max_of_left = B[j-1]
            elif j == 0: max_of_left = A[i-1]
            else: max_of_left = max(A[i-1], B[j-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(A[i], B[j])

            return (max_of_left + min_of_right) / 2.0