leetcode刷题记录2021年3月19日

题目描述

寻找两个正序数组的中位数
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

示例 3：
输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000

示例 4：
输入：nums1 = [], nums2 = [1]
输出：1.00000

示例 5：
输入：nums1 = [2], nums2 = []
输出：2.00000

范围：
nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-10^6 <= nums1[i], nums2[i] <= 10^6

思路有两种，暂时只研究了其中一种，另一种等等再说。

思路

思路是leetcode cookbook这本书上的。

寻找中位数的问题可以看成寻找把数组划成两部分的那条线，线的旁边就是中位数，因为现在是寻找两个数组合并之后的中位数，如果先合并在找铁定时间不够。
我们可以先将其中一个划分成两半，那么另一个数组的划分也就确定了，因为中位数的位置是固定的，所以只需要确定一个数组的划分方式，如何判断当前的划分是否正确呢，只要保证这两条线左边最大的值小于右边最小的值就行了，一个简单的比较即可。
假设其中一个划分是在num1数组的第n-1个数和第n个数之间和num2数组的第m-1的第m个数之间，那么，只要满足：

max(num1[n-1],num2[m-1])<min(num1[n],num2[m])

这种划分就是正确的，假设(n+m)%2==0，那么，中位数就是

(max(num1[n-1],num2[m-1])+min(num1[n],num2[m]))/2

反之，中位数是：

max(num1[n-1],num2[m-1])

因为是有序数组，所以上面的式子可以可以简化成：

num1[n-1]<num2[m]&&num2[m-1]<num1[n]

因此，整个算法就可以围绕着其中一个数组的划分上，由于要降低时间复杂度，所以用二分搜索来实现划分的查找以及选择较小的数组进行查找

编程细节

虽然上面的思路并不复杂，但是实现的时候有很多需要注意的地方，尤其是我还是个初学者，我看的leetcode cookbook上的实现很多地方的细节都看不懂，因此在研究了一番之后，总结了一下理解这个实现所需要的一些前提。

二分算法

程序的主题就是二分算法的一个魔改
基础模板

void test_erfen()
{
    int p[50],l=0,r=50-1,n=50;
    srand(NULL);
    for(int i=0;i<1;i++)
        p[i]=i;
    int mid = (l+r)/2;
    while(l<=r)
    {
        mid=(l+r)/2;
        //mid=l+(r-l)>>1; 可能比较快
        if(p[mid]<49)
            l=mid+1;
        else if(p[mid]>49)
            r=mid-1;
        else
            break;
    }
}

二分查找最基础的几个变量有代表当前范围的范围的left，right，注意这是两边都闭合的区间，代表当前查找对象的mid，结束之后，mid就是结果，查找不到就是left>right，

中位数

数组长度为n
奇数：num[(n+1)/2]
偶数：(num[n/2] + num[n/2-1])/2
在这个程序中，利用了c语言整数相除向下取整的特性，将偶数的变了一下，变成了：
(num[(n+1)/2] + num[(n+1)/2-1])/2
因此index设置的是(nums1Size+nums2Size+1)/2
换一种设置也行，就是最后的处理也需要跟着变一下。

坑

程序里的一个小小的细节，在设置左右边界的时候：

int left=0,right=smallsize;

题解

和二分查找那里不一样，这个程序的查找范围就是[0,smallsize]，那条线是可以划到程序的头上的，所有有这个。

double max(double a,double b)
{
    if(a>b)return a;
    else return b;
}
double min(double a,double b)
{
    if(a<b)return a;
    else return b;
}
double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size){

    int index = (nums1Size+nums2Size+1)/2;
    int* smallone,*bigone,smallsize,bigsize;
    smallone = nums1Size<nums2Size?nums1:nums2;
    bigone =  nums1Size>=nums2Size?nums1:nums2;
    smallsize = nums1Size<nums2Size?nums1Size:nums2Size;
    bigsize = nums1Size>=nums2Size?nums1Size:nums2Size;

    int start = smallsize/2;
    int start_t = index-start;
    int left=0,right=smallsize;
    while(left<=right){
        start = left + (right - left)/2;
        start_t = index - start;
        printf("%d %d %d %d\n",left,right,start,start_t);
        if(start>0 && smallone[start-1]>bigone[start_t])
            right = start - 1;
        else if (start!=smallsize && smallone[start] < bigone[start_t-1])
            left = start + 1;
        else
            break;
    }
    double small,big;
    if(start == 0)
        small = bigone[start_t-1];
    else if (start_t == 0)
        small = smallone[start-1];
    else
        small = max(bigone[start_t-1],smallone[start-1]);

    if((nums1Size+nums2Size)%2==1)return small;
    if(start == smallsize)
        big = bigone[start_t];
    else if(start_t == bigsize)
        big = smallone[start];
    else
        big = min(smallone[start],bigone[start_t]);
    return (small+big)/2;
}