題目為：

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

大意就是求出兩個已排序陣列的中位數.  如果總共有偶數個元素, 返回兩個中間數的和的一半. 所以返回型別是double

還要求時間複雜度為O(log (m+n)).

初看這題,馬上想到的就是使用 merge sort,將兩個數組合並起來後直接返回中間數, 這樣非常省力.但時間複雜度平均下倆就是O(m+n)

如下所示：

double findMedianSortedArrays(int A[], int m, int B[], int n) {
		int i = 0, j = 0, k = 0;
		int *C = new int[m+n];
		while (i < m && j < n)
		{
			if (A[i] < B[j])
				C[k++] = A[i++];
			else
				C[k++] = B[j++];
		}

		while (i < m)
			C[k++] = A[i++];

		while (j < n)
			C[k++] = B[j++];

		int mid = (m + n) / 2;
		if ((m + n) % 2 == 0)
			return (double)(C[mid] + C[mid - 1]) / 2;
		else
			return C[mid];
	}
 

既然無法達到要求, 那麼只能換一種思路. 根據題目給出的時間複雜度, 我們一般會想到的排序方法有merge sort, quick sort等

對於查詢的演算法, 比如二分查詢,  或是利用二叉樹的變形來查詢, 雜湊查詢顯然更快, 但明顯不適合這裡.

所以, 最終選擇了二分查詢.

下面是參考了別人的程式碼：

#include <stdio.h>

//這個二分查詢, 找到目標value就會返回其下標; 如果沒有找到, 會返回它應該插入的位置
int BinarySearch(int *nums, int start, int end, int value){
	int mid; 
	while(start <= end){
		mid = start + (end - start) / 2;
		if(nums[mid] >= value)
			end = mid - 1;
		else
			start = mid + 1;
	}

	return start;
}

//以下部分引數為二分查詢所需
double recusiveFindMedian(int *A, int m, int *B, int n, int A_Start, int A_End, int B_Start, int B_End){
	//A_Mid表示A陣列中間數的下標, 也表示在A陣列中, 該數之前有多少個數字
	int A_Mid = A_Start + (A_End - A_Start) / 2;
	//找到A陣列的中間數在B中的位置. 也表示在B陣列中, 該數之前有多少個數字
	int A_Mid_Pos_In_B = BinarySearch(B, B_Start, B_End, A[A_Mid]);
	//最終就得到了合併後, 該數之前會有多少個數存在
	int A_Mid_Final = A_Mid + A_Mid_Pos_In_B;

	//如果這個數在最終合併的陣列中仍然處於中間位置
	//那麼就繼續考慮合併後的陣列的元素個數是偶數還是奇數.
	//如果合併後有奇數個數字, 直接返回這個數;
	//如果合併後有偶數個數字, 那麼返回這個數和這個數之前的數的和的一半
	if(A_Mid_Final == (m + n)/2){
		//比如陣列A：[1, 3, 5]; 陣列B：[2, 4]; 那麼
		//	A_Mid = 1; A_Mid_Pos_In_B = 1; A_Mid_Final = 2 == (m + n) / 2; 直接返回就可以
		//比如陣列A：[3, 5]; 陣列B：[1, 2, 4]; 那麼
		//	A_Mid = 0; A_Mid_Pos_In_B = 2; A_Mid_Final = 2 == (m + n) / 2; 依舊直接返回
		//比如陣列A：[5, 9]; 陣列B：[2, 4]; 那麼
		//	A_Mid = 0; A_Mid_Pos_In_B = 2; A_Mid_Final = 2 == (m + n) / 2;
		//	因為是偶數個元素, 所以最終返回 (A[0] +B [1])/2 = 4.5
		if((m + n) & 1)
			return A[A_Mid];

		int prev;
		//既然 A_Mid 等於偶數的一半, 比如(2+4)/2 = 3; 那麼最終的返回值應該是合併後的(M[3]+M[2])/2才對
		//因為 0,1,2,3,4,5 中間兩個數是2和3
		//但是如果出現 (1 + 3)/2 = 2的情況,比如
		//	[2, 3, 4]; [5]; 此時A_Mid_Pos_In_B = 0, 這時候只能返回 (A[1]+A[2])/2
		//又或者這種情況：
		//	[3]; [2, 4 ,5]; 此時就要 (A[0] + B[1])/2
		//又或者兩陣列都只有1個元素, 這樣只要返回兩數和的一半就行了
		//其他普通情況就是從A陣列或B陣列中挑一個小於A_Mid又離的最近的就行了
		if(A_Mid > 0 && A_Mid_Pos_In_B > 0)
			prev = A[A_Mid-1] > B[A_Mid_Pos_In_B-1] ? A[A_Mid-1] : B[A_Mid_Pos_In_B-1];
		else if(A_Mid > 0)
			prev = A[A_Mid - 1];
		else if(A_Mid_Pos_In_B > 0)
			prev = B[A_Mid_Pos_In_B - 1];
		else
			prev = B[A_Mid_Pos_In_B];

		return (A[A_Mid] + prev) / 2.0 ;
	}
	else if(A_Mid_Final < (m + n)/2){
		//既然這個數在合併後的陣列中的位置是在左半邊的, 那麼我們就要用比這個數大的數來繼續尋找
		//就是二分查詢的概念, 現在往右邊找
		//在A陣列中, A_Mid肯定不符合要求了, 所以加一往後找
		//在B陣列中, A_Mid_Pos_In_B可能與A_Mid的值相同, 也可能是A_Mid對應的值應該要插入的位置, 所以不能加一
		A_Start = A_Mid + 1;
		B_Start = A_Mid_Pos_In_B;
		if((A_End - A_Start) > (B_End - B_Start))
			return recusiveFindMedian(A, m, B, n, A_Start, A_End, B_Start, B_End);
		return recusiveFindMedian(B, n, A, m, B_Start, B_End, A_Start, A_End);
	}
	else{
		//這裡能減1是有多個條件促成的
		//	A陣列是較長的陣列
		//	A陣列中的中間數在合併後的陣列的右邊
		A_End = A_Mid - 1;
		//B陣列能捨棄一些元素是因為, 兩個陣列是sorted的
		//這裡能減1也是因為A_Mid_Pos_In_B可能與A_Mid的值相同, 也可能是A_Mid對應的值應該要插入的位置
		B_End = A_Mid_Pos_In_B - 1;	
		if((A_End - A_Start) > (B_End - B_Start))
			return recusiveFindMedian(A, m, B, n, A_Start, A_End, B_Start, B_End);
		return recusiveFindMedian(B, n, A, m, B_Start, B_End, A_Start, A_End);
	}
}

double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size){
	if(nums1Size == 0 && nums2Size == 0)
		return 0.0;
	
	if(nums1Size == 0)
		return (nums2Size%2==1 ? nums2[nums2Size/2] : (nums2[nums2Size/2-1] + nums2[nums2Size/2])/2.0);

	if(nums2Size == 0)
		return (nums1Size%2==1 ? nums1[nums1Size/2] : (nums1[nums1Size/2-1] + nums1[nums1Size/2])/2.0);
	
	//下面我們保證recusiveFindMedian中A的陣列長度一定是不小於B的
	if(nums1Size > nums2Size)
		return recusiveFindMedian(nums1, nums1Size, nums2, nums2Size, 0, nums1Size-1, 0, nums2Size-1);
	
	return recusiveFindMedian(nums2, nums2Size, nums1, nums1Size, 0, nums2Size-1, 0, nums1Size-1);
}

int main()
{
	int ar1[] = {1, 12, 15, 26, 38};
	int ar2[] = {2, 13, 17, 30, 45, 50};
	printf("Median is 17 = %f\n", findMedianSortedArrays(ar1, 5, ar2, 6));
	return 0;
}
 

這又讓人想起了快速排序中的Partition演算法...