「这是我参与2022首次更文挑战的第2天，活动详情查看：2022首次更文挑战」。
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数 。算法的时间复杂度应该为 O(log (m+n)) 。
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
朴素解
本题属于困难题，其困难之处主要在于时间复杂度为O(log (m+n))，最简单的思路为合并给定的两个数组，由于数组已经有序，因此可以一起遍历两个数组，比较头元素的大小，然后开辟一个新的数组，数组大小为m+n，之后根据数组长度的奇数或者偶数来计算中位数。本题需要注意的一个细节就是输入的两个数组长度可能为0，因此需要事先判断数组长度，如果存在一个数组长度为0则只需计算另一个数组即可，代码如下：
public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
int m = nums1.length;
int n = nums2.length;
if(m==0){
if(n%2==0){
return (nums2[n/2] + nums2[n/2-1])/2.0;
}
else{
return nums2[n/2];
}
}
if(n==0){
if(m%2==0){
return (nums1[m/2] + nums1[m/2-1])/2.0;
}
else{
return nums1[m/2];
}
}
int[] nums = new int[m + n];
int i = 0,j = 0,count=0;
while(count!=(m+n)){
if(i == m){
while(j!=n){
nums[count++] = nums2[j++];
}
break;
}
if(j == n){
while (i!=m){
nums[count++] = nums1[i++];
}
break;
}
if(nums1[i]<nums2[j]){
nums[count++] = nums1[i++];
}else {
nums[count++] = nums2[j++];
}
}
if(nums.length%2==0){
return (nums[nums.length/2] + nums[nums.length/2-1])/2.0;
}else {
return nums[nums.length/2];
}
}
该方法得出的结果由于新开辟了一个数组，因此空间复杂度为O(m+n)，遍历两个数组的时间复杂第为O(m+n)。Leetcode运行情况：
但实际要求的时间复杂度为O(log (m+n))，此解法显然不符合。
解法二
实际上，对于合并后的数组，我们并不需要合并后数组的所有元素，只需要获得合并后的len/2个元素即可，如果len是偶数，则中位数就是最后一个元素加上前一个元素的均值，如果len是奇数，则中位数就是最后一个元素。代码如下：
public static double findMedianSortedArrays2(int[] nums1, int[] nums2){
int len = nums1.length + nums2.length;
int left = -1, right = -1;
int index1 = 0, index2 = 0;
for(int i=0;i<=len/2;i++){
left = right;
if(index1<nums1.length&&(index2>=nums2.length||nums1[index1]<nums2[index2])){
right = nums1[index1++];
}else {
right = nums2[index2++];
}
}
if(len%2==0){
return (left + right) / 2.0;
}else {
return right;
}
}
上述if判断条件需要注意，如果nums1数组尚未遍历完，则判断条件为index1<nums1.length&&nums1[index1]<nums2[index2]，此时nums2需要保证没有遍历完，如果nums2已经遍历完，则满足条件index1<nums1.length&&index2>=nums2.length。由于遍历过程中，我们只用了有限的变量，因此空间复杂度为O(1)，而循环len/2次，时间复杂度为O(m+n)。虽然leetcode执行已经达到100%，但显然仍不是最优解。
最优解
看到了时间复杂度为log级别，那么在我们熟知的方法中，存在的方法就是二分法，该方法思路很简单，首先对于两个有序数组，计算两个数组的长度之和len，如果和为奇数，则中位数就是第len/2个数，如果长度之和为偶数，则中位数就是第len/2和len/2+1的均值，因此该问题就转变为求两个数组第k小数。求解思路为：
首先两个数组长度之和为len，数组一的长度为len1，数组二的长度为len2，假设情况为奇数，此时k就等于len/2，首先分别比较数组一len1/2位置和数组二len2/2位置值的大小，如果数组一小于数组二，则代表数组一的len1/2位置之前的所有数字都不是，则排除，此时数组一index移到len/2+1位置，k更新为k-k/2，依次类推，注意还需要先判断一下是否存在已经有一个数组索引越界。代码如下（参考LeetCode官方解答）：
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int length1 = nums1.length, length2 = nums2.length;
int totalLength = length1 + length2;
if (totalLength % 2 == 1) {
int midIndex = totalLength / 2;
double median = getKthElement(nums1, nums2, midIndex + 1);
return median;
} else {
int midIndex1 = totalLength / 2 - 1, midIndex2 = totalLength / 2;
double median = (getKthElement(nums1, nums2, midIndex1 + 1) + getKthElement(nums1, nums2, midIndex2 + 1)) / 2.0;
return median;
}
}
public int getKthElement(int[] nums1, int[] nums2, int k) {
/* 主要思路：要找到第 k (k>1) 小的元素，那么就取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较
* 这里的 "/" 表示整除
* nums1 中小于等于 pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个
* nums2 中小于等于 pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个
* 取 pivot = min(pivot1, pivot2)，两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个
* 这样 pivot 本身最大也只能是第 k-1 小的元素
* 如果 pivot = pivot1，那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums1 数组
* 如果 pivot = pivot2，那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums2 数组
* 由于我们 "删除" 了一些元素（这些元素都比第 k 小的元素要小），因此需要修改 k 的值，减去删除的数的个数
*/
int length1 = nums1.length, length2 = nums2.length;
int index1 = 0, index2 = 0;
int kthElement = 0;
while (true) {
// 边界情况
if (index1 == length1) {
return nums2[index2 + k - 1];
}
if (index2 == length2) {
return nums1[index1 + k - 1];
}
if (k == 1) {
return Math.min(nums1[index1], nums2[index2]);
}
// 正常情况
int half = k / 2;
int newIndex1 = Math.min(index1 + half, length1) - 1;
int newIndex2 = Math.min(index2 + half, length2) - 1;
int pivot1 = nums1[newIndex1], pivot2 = nums2[newIndex2];
if (pivot1 <= pivot2) {
k -= (newIndex1 - index1 + 1);
index1 = newIndex1 + 1;
} else {
k -= (newIndex2 - index2 + 1);
index2 = newIndex2 + 1;
}
}
}
}
