LeetCode刷题笔记 4

题目：
给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。请找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。假设 nums1 和 nums2 不会同时为空。
eg：nums1 = [1, 3] nums2 = [2] 则中位数是 2.0
nums1 = [1, 2] nums2 = [3, 4] 则中位数是 (2 + 3)/2 = 2.5

我的答案：
在错误的方法上刚了5小时，得出结论：以后如果2小时写不出来直接看答案，在错误的道路上及时停止就是一种进步。学习别人的方法也很高效。

答案：
方法一：
二分法
A[0], A[1], …, A[i-1] | A[i], A[i+1], …, A[m-1]
B[0], B[1], …, B[j-1] | B[j], B[j+1], …, B[n-1]
将两个数组分为左右两部分，使
len(left_part)=len(right_part)
max(left_part)≤min(right_part)
在这里插入图片描述

class Solution {
    public double findMedianSortedArrays(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;
            //i增大j就会被减小，因此B[j−1]会减小，而A[i]会增大，那么B[j−1]≤A[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.0;
            }
        }
        return 0.0;
    }
}

时间复杂度：O(log(min(m,n))),首先，查找的区间是 [0, m]。而该区间的长度在每次循环之后都会减少为原来的一半。所以，我们只需要执行 log(m) 次循环。
空间复杂度：O(1)

方法二：
遍历
将两个数组从小到大排序，然后找到中间位置的值

double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size)
{
    int i,j,median;
    int t=0;
    i=j=median=0;
    int sum[nums1Size+nums2Size];
    memset(sum,0,nums1Size+nums2Size);
    while(i<nums1Size&&j<nums2Size)                                
    {
        if(nums1[i]>=nums2[j]) 
        {
            sum[t]=nums2[j];
            j++;
        }
        else 
        {
            sum[t]=nums1[i];
            i++;
        }
        t++;
    }
    while(i<nums1Size)
    {         
        sum[t]=nums1[i];
        t++;
        i++;
    }
    while(j<nums2Size)
    {
        {
            sum[t]=nums2[j];
            t++;
            j++;
        }
    }   
    int a=t/2;
    int b=t/2-1;
    if(t%2==0)
    {
        return (1.0*(sum[a]+sum[b]))/2;
    }
    else
        return 1.0*sum[a];
}

需要注意的地方：

二分法及递归法的思路
整数相除值仍为整数，若想为小数，应采取比如5/2.0的方法
返回值需要在最后也注明，不影响代码中返回
数组的赋值为大括号
java 跳出多层循环可以采用break label； 的方式（将label：标识在循环外）；也可采用return
c语言menset函数：void *memset(void *s,int c,size_t n) 总的作用：将已开辟内存空间s的首n个字节的值设为值c。

猜你喜欢