leetcode 4. 寻找两个有序数组的中位数（任意第k小的数） hard

leetcode 4. 寻找两个有序数组的中位数  hard          

题目描述：

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

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

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

示例 1:

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

则中位数是 2.0

解题思路：

这破题有点难，没得意思

解释：    https://www.acwing.com/solution/LeetCode/content/50/

代码：

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int n=nums1.size();
        int m=nums2.size();
        if(n>m) return findMedianSortedArrays(nums2,nums1);// 只割最小的
        
        int lo=0,hi=n*2;  //添虚拟元素
        double l1,l2,r1,r2;
        while(lo<=hi){
            int mid1 = (lo+hi)/2;
            int mid2 = n+m-mid1;
             
            l1 = (mid1==0)?INT_MIN:nums1[(mid1-1)/2]; //mid1==0的时候保证l1<=r2 永远成立
            l2 = (mid2==0)?INT_MIN:nums2[(mid2-1)/2];
            r1 = (mid1==2*n)?INT_MAX:nums1[mid1/2];
            r2 = (mid2==2*m)?INT_MAX:nums2[mid2/2];
            
            if(l1>r2)
                hi=mid1-1;  //l1割多了
            else if(l2>r1)
                lo = mid1+1; // l2割少了，也就是l1割多了
            else
                return (max(l1,l2)+min(r1,r2))/2;
        }
        
        return -1;
    }
};

任意第k小的数

    充分利用两个数组都是有序的条件：
    1）当array1[k/2-1] == array2[k/2-1] 则返回array1[k/2-1]或者array2[k/2-1]
    2）当array1[k/2-1] > array2[k/2-1]  则array2在[0,k/2-1]范围内的元素一定比array1、array2合并后第k个元素小，可以不用考虑array2在[0,k/2-1]范围内的元素
    3）当array1[k/2-1] < array2[k/2-1]  则array1在[0,k/2-1]范围内的元素一定比array1、array2合并后第k个元素小，可以不用考虑array1在[0,k/2-1]范围内的元素
     因此算法可以写成一个递归的形式，递归结束的条件为：
    1）array1[k/2-1] == array2[k/2-1] return array1[k/2-1]
    2）array1或者array2为空时，return array1[k-1]或者array2[k-1]
    3）k==1时，返回min(array1[0],array2[0])
    时间复杂度O(log(m+n))
 

 

using namespace std;
#define min(a,b)  (a<b?a:b)
int findKth(vector<int> &arr1, int begin1, vector<int>& arr2, int begin2, int k) {
	if ((int)arr1.size() - begin1>(int)arr2.size() - begin2) // 默认arr1的剩余size比较小
		return findKth(arr2, begin2, arr1, begin1, k);
	
	if (begin1 >= arr1.size())
		return arr2[begin2 + k - 1];
	if (k == 1)
		return min(arr1[begin1], arr2[begin2]);

	int n1 = min(k / 2, arr1.size()-begin1);  // 不能过界
	int n2 = k - n1;
	
	if (arr1[begin1 + n1 - 1]>arr2[begin2 + n2 - 1])
		return findKth(arr1, begin1, arr2, begin2 + n2, k - n2);
	else if (arr1[begin1 + n1 - 1]<arr2[begin2 + n2 - 1])
		return findKth(arr1, begin1 + n1, arr2, begin2, k - n1);
	return arr1[begin1 + n1 - 1];


}


int Binary_find_Kth(int* array1, int len1, int* array2, int len2, int k)
{
	/**在这里始终认为len1<len2**/
	if (len1>len2) return Binary_find_Kth(array2, len2, array1, len1, k);
	if (len1 == 0) return array2[k - 1];
	if (k == 1) return min(array1[0], array2[0]);

	/**将k分为两部分，分别在array1和array2数组上查找**/
	int k1 = min(k / 2, len1);
	int k2 = k - k1;

	/**
	说明array2的k2-1前部分一定在第k大元素之前，因此：
	1）将k2-1这部分全跳过:更新数组首位地址索引，同时更新数组长度；
	2）将这k2元素纳入已找到的第k大元素范围内，更新k值：k-k2
	**/
	if (array1[k1 - 1] > array2[k2 - 1])
		return Binary_find_Kth(array1, len1, array2 + k2, len2 - k2, k - k2);
	/**
	说明array1的k1-1前部分一定在第k大元素之前，因此：
	1）将k1-1这部分全跳过:更新数组首位地址索引，同时更新数组长度；
	2）将这k1元素纳入已找到的第k大元素范围内，更新k值：k-k1
	**/
	else if (array1[k1 - 1] < array2[k2 - 1])
		return Binary_find_Kth(array1 + k1, len1 - k1, array2, len2, k - k1);

	else
		return array1[k1 - 1];
}