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];
}