寻找两个有序数组的中位数

题目

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

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

则中位数是 2.0

示例 2:

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

则中位数是 (2 + 3)/2 = 2.5

答案

1.合并数组

将两个数组合并到一个大的数组中，再对大的数组的长度进行就判断，从而找出中位数。
这种做法的时间复杂度为O(m + n) = O(n)很显然这种做法是不满足O(log(m + n)) = O(logn)。

public static float method1(int[] nums1, int[] nums2 ){
		int l1 = nums1.length;
		int l2 = nums2.length;
		int[] sum = new int[l1 + l2];
		int index1 = 0;
		int index2 = 0;
		while(index1 < l1 && index2 < l2) {
			if(nums1[index1] >= nums2[index2]) {
				sum[index1 + index2] = nums2[index2];
				index2++;
			}else {
				sum[index1 + index2] = nums1[index1];
				index1++;
			}
		}
		if(index1 == l1) {
			while(index2 < l2) {
				sum[index1 + index2] = nums2[index2];
				index2++;
			}
		}else {
			while(index1 < l1) {
				sum[index1 + index2] = nums1[index1];
				index1++;
			}
		}
		int mid = sum.length / 2;
		if( sum.length % 2 == 0) {
			return (sum[mid] + sum[ mid  - 1]) / 2.0f;
		}else {
			return sum[mid];
		}
	}

2.递归法

这种目前还没有看懂，我只能想到第一种，先放着，实力提升了再来解决。

public static float method2(int[] A, int[] B) {
		        int m = A.length;
		        int n = B.length;
		        if (m > n) { // to ensure m<=n
		            int[] temp = A; A = B; B = temp;
		            int tmp = m; m = n; n = tmp;
		        }
		        int iMin = 0, iMax = m, halfLen = (m + n + 1) / 2;
		        while (iMin <= iMax) {
		            int i = (iMin + iMax) / 2;
		            int j = halfLen - i;
		            if (i < iMax && B[j-1] > A[i]){
		                iMin = i + 1; // i is too small
		            }
		            else if (i > iMin && A[i-1] > B[j]) {
		                iMax = i - 1; // i is too big
		            }
		            else { // i is perfect
		                int maxLeft = 0;
		                if (i == 0) { 
		                	maxLeft = B[j-1];
		                	}
		                else if (j == 0) {
		                	maxLeft = A[i-1];
		                	}
		                else { 
		                	maxLeft = Math.max(A[i-1], B[j-1]); 
		                	}
		                if ( (m + n) % 2 == 1 ) {
		                	return maxLeft;
		                }

		                int minRight = 0;
		                if (i == m) {
		                	minRight = B[j];
		                	}
		                else if (j == n) {
		                	minRight = A[i];
		                	}
		                else { 
		                	minRight = Math.min(B[j], A[i]);
		                	}

		                return (maxLeft + minRight) / 2.0f;
		            }
		        }
		        return 0.0f;
		    }

全部代码如下：

package leetCode;

public class FindMedianSortedArrays {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int[] nums1 = {1, 2};
		int[] nums2 = {3,4};
		float result = 0;
		result = method1(nums1, nums2);
//		result = method2(nums1, nums2);
		System.out.println(result);
	}

	public static float method1(int[] nums1, int[] nums2 ){
		int l1 = nums1.length;
		int l2 = nums2.length;
		int[] sum = new int[l1 + l2];
		int index1 = 0;
		int index2 = 0;
		while(index1 < l1 && index2 < l2) {
			if(nums1[index1] >= nums2[index2]) {
				sum[index1 + index2] = nums2[index2];
				index2++;
			}else {
				sum[index1 + index2] = nums1[index1];
				index1++;
			}
		}
		if(index1 == l1) {
			while(index2 < l2) {
				sum[index1 + index2] = nums2[index2];
				index2++;
			}
		}else {
			while(index1 < l1) {
				sum[index1 + index2] = nums1[index1];
				index1++;
			}
		}
		int mid = sum.length / 2;
		if( sum.length % 2 == 0) {
			return (sum[mid] + sum[ mid  - 1]) / 2.0f;
		}else {
			return sum[mid];
		}
	}

	public static float method2(int[] A, int[] B) {
		        int m = A.length;
		        int n = B.length;
		        if (m > n) { // to ensure m<=n
		            int[] temp = A; A = B; B = temp;
		            int tmp = m; m = n; n = tmp;
		        }
		        int iMin = 0, iMax = m, halfLen = (m + n + 1) / 2;
		        while (iMin <= iMax) {
		            int i = (iMin + iMax) / 2;
		            int j = halfLen - i;
		            if (i < iMax && B[j-1] > A[i]){
		                iMin = i + 1; // i is too small
		            }
		            else if (i > iMin && A[i-1] > B[j]) {
		                iMax = i - 1; // i is too big
		            }
		            else { // i is perfect
		                int maxLeft = 0;
		                if (i == 0) { 
		                	maxLeft = B[j-1];
		                	}
		                else if (j == 0) {
		                	maxLeft = A[i-1];
		                	}
		                else { 
		                	maxLeft = Math.max(A[i-1], B[j-1]); 
		                	}
		                if ( (m + n) % 2 == 1 ) {
		                	return maxLeft;
		                }

		                int minRight = 0;
		                if (i == m) {
		                	minRight = B[j];
		                	}
		                else if (j == n) {
		                	minRight = A[i];
		                	}
		                else { 
		                	minRight = Math.min(B[j], A[i]);
		                	}

		                return (maxLeft + minRight) / 2.0f;
		            }
		        }
		        return 0.0f;
		    }
}