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 .

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
```

这题有点意思，的做法我想大家都应该会，就是类似merge_sort合并的步骤，那么时间复杂度为该怎么写.

Assume that the number of elements in A and B are both larger than k/2, and if we compare the k/2-th smallest element in A(i.e. A[k/2-1]) and the k-th smallest element in B(i.e. B[k/2 – 1]), there are three results:

(Becasue k can be odd or even number, so we assume k is even number here for simplicy. The following is also true when k is an odd number.)

A[k/2-1] = B[k/2-1]

A[k/2-1] > B[k/2-1]

A[k/2-1] < B[k/2-1]

if A[k/2-1] < B[k/2-1], that means all the elements from A[0] to A[k/2-1](i.e. the k/2 smallest elements in A) are in the range of k smallest elements in the union of A and B. Or, in the other word, A[k/2 – 1] can never be larger than the k-th smalleset element in the union of A and B.

Why?

We can use a proof by contradiction. Since A[k/2 – 1] is larger than the k-th smallest element in the union of A and B, then we assume it is the (k+1)-th smallest one. Since it is smaller than B[k/2 – 1], then B[k/2 – 1] should be at least the (k+2)-th smallest one. So there are at most (k/2-1) elements smaller than A[k/2-1] in A, and at most (k/2 – 1) elements smaller than A[k/2-1] in B.So the total number is k/2+k/2-2, which, no matter when k is odd or even, is surly smaller than k(since A[k/2-1] is the (k+1)-th smallest element). So A[k/2-1] can never larger than the k-th smallest element in the union of A and B if A[k/2-1] Since there is such an important conclusion, we can safely drop the first k/2 element in A, which are definitaly smaller than k-th element in the union of A and B. This is also true for the A[k/2-1] > B[k/2-1] condition, which we should drop the elements in B.

When A[k/2-1] = B[k/2-1], then we have found the k-th smallest element, that is the equal element, we can call it m. There are each (k/2-1) numbers smaller than m in A and B, so m must be the k-th smallest number. So we can call a function recursively, when A[k/2-1] < B[k/2-1], we drop the elements in A, else we drop the elements in B.

We should also consider the edge case, that is, when should we stop?

1. When A or B is empty, we return B[k-1]( or A[k-1]), respectively;

2. When k is 1(when A and B are both not empty), we return the smaller one of A[0] and B[0]

3. When A[k/2-1] = B[k/2-1], we should return one of them

In the code, we check if m is larger than n to garentee that the we always know the smaller array, for coding simplicy.

Assume that the number of elements in A and B are both larger than k/2, and if we compare the k/2-th smallest element in A(i.e. A[k/2-1]) and the k-th smallest element in B(i.e. B[k/2 – 1]), there are three results:

(Becasue k can be odd or even number, so we assume k is even number here for simplicy. The following is also true when k is an odd number.)

A[k/2-1] = B[k/2-1]

A[k/2-1] > B[k/2-1]

A[k/2-1] < B[k/2-1]

if A[k/2-1] < B[k/2-1], that means all the elements from A[0] to A[k/2-1](i.e. the k/2 smallest elements in A) are in the range of k smallest elements in the union of A and B. Or, in the other word, A[k/2 – 1] can never be larger than the k-th smalleset element in the union of A and B.

Why?

We can use a proof by contradiction. Since A[k/2 – 1] is larger than the k-th smallest element in the union of A and B, then we assume it is the (k+1)-th smallest one. Since it is smaller than B[k/2 – 1], then B[k/2 – 1] should be at least the (k+2)-th smallest one. So there are at most (k/2-1) elements smaller than A[k/2-1] in A, and at most (k/2 – 1) elements smaller than A[k/2-1] in B.So the total number is k/2+k/2-2, which, no matter when k is odd or even, is surly smaller than k(since A[k/2-1] is the (k+1)-th smallest element). So A[k/2-1] can never larger than the k-th smallest element in the union of A and B if A[k/2-1] Since there is such an important conclusion, we can safely drop the first k/2 element in A, which are definitaly smaller than k-th element in the union of A and B. This is also true for the A[k/2-1] > B[k/2-1] condition, which we should drop the elements in B.

When A[k/2-1] = B[k/2-1], then we have found the k-th smallest element, that is the equal element, we can call it m. There are each (k/2-1) numbers smaller than m in A and B, so m must be the k-th smallest number. So we can call a function recursively, when A[k/2-1] < B[k/2-1], we drop the elements in A, else we drop the elements in B.

We should also consider the edge case, that is, when should we stop?

1. When A or B is empty, we return B[k-1]( or A[k-1]), respectively;

2. When k is 1(when A and B are both not empty), we return the smaller one of A[0] and B[0]

3. When A[k/2-1] = B[k/2-1], we should return one of them

In the code, we check if m is larger than n to garentee that the we always know the smaller array, for coding simplicy.

代码：

```
#include <stdio.h>
double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size);
double findKth(int* nums1, int nums1Size, int* nums2, int nums2Size,int k);
int min(int a,int b)
{
if(a>b)
return b;
else
return a;
}
int main(void)
{
int nums1[10]={0,1,2,3,4,5,6,7,8,9};
int nums2[5]={2,14,16,18,19};
printf("%lf",findMedianSortedArrays(nums1,10,nums2,5));
return 0;
}
double findMedianSortedArrays(int A[], int m, int B[], int n)
{
int total = m + n;
if (total & 0x1)
return findKth(A, m, B, n, total / 2 + 1);
else
return (findKth(A, m, B, n, total / 2)
+ findKth(A, m, B, n, total / 2 + 1)) / 2;
}
double findKth(int* nums1, int nums1Size, int* nums2, int nums2Size,int k)
{
if(nums1Size>nums2Size)
return findKth(nums2,nums2Size,nums1,nums1Size,k);
if(nums1Size==0)
return nums2[k-1];
if(k==1)
return min(nums1[0],nums2[0]);
int pa=min(k/2,nums1Size),pb=k-pa;
if(nums1[pa-1]<nums2[pb-1])
return findKth(nums1+pa,nums1Size-pa,nums2,nums2Size,k-pa);
else if(nums1[pa-1]>nums2[pb-1])
return findKth(nums1,nums1Size,nums2+pb,nums2Size-pb,k-pb);
else
return nums1[pa-1];
}
```