68.寻找两个正序数组的中位数

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

算法的时间复杂度应该为 O(log (m+n)) 。

示例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

提示：

• nums1.length == m
• nums2.length == n
• 0 <= m <= 1000
• 0 <= n <= 1000
• 1 <= m + n <= 2000
• -10⁶ <= nums1[i], nums2[i] <= 10⁶

代码：
1.合并后划分

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        //创建一个ArrayList用于合并两个有序数组
        List<Integer>list = new ArrayList<>();
        //初始化两个指针i和j，分别用于遍历nums1和nums2
        int i,j;
        //用于存储最终结果的变量
        double res = 0;
        //合并两个有序数组
        //当两个数组都还有元素时进行比较
        for(i = 0,j = 0;i<nums1.length&&j<nums2.length;){
            //将较小的元素添加到list中，并移动相应指针
            if(nums1[i]<=nums2[j])list.add(nums1[i++]);
            else list.add(nums2[j++]);
        }
        //如果nums1还有剩余元素，全部添加到list中
        while(i<nums1.length)list.add(nums1[i++]);
        //如果nums2还有剩余元素，全部添加到list中
        while(j<nums2.length)list.add(nums2[j++]);
        //如果元素个数为偶数，中位数是中间两个数的平均值
        if(list.size()%2==0)res = (list.get(list.size()/2)+list.get(list.size()/2-1))*1.0/2;
        //如果元素个数为奇数，中位数就是中间的数
        else res = list.get(list.size()/2);
        //返回中位数结果
        return res;
    }
}

2.划分数组

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        //确保nums1是较短的数组，以优化时间复杂度
        if(nums1.length > nums2.length)return findMedianSortedArrays(nums2,nums1);
        //m为nums1的数组长度
        int m = nums1.length;
        //n为num2的数组长度
        int n = nums2.length;
        int l = 0,r = m;
        //median1为前一部分的最大值，median2为后一部分的最小值
        int median1 = 0,median2 = 0;
        while(l<=r){
            int partitionX = l+r>>1;
            int partitionY = ((m+n+1)>>1)-partitionX;
            //处理边界情况
            //maxLX:nums1左半部分的最大值
            //如果partitionX == 0，表示nums1的左半部分为空，此时用Integer.MIN_VALUE表示负无穷，保证任何nums2的左半部分值都比它大
            //否则nums1左半部分的最大值是nums1[partitionX - 1]（因为 nums1 是有序的，左半部分的最后一个元素就是最大值）
            int maxLX = partitionX == 0 ? Integer.MIN_VALUE:nums1[partitionX-1];

            //minRX:nums1右半部分的最小值
            //如果partitionX == m，表示nums1的右半部分为空，此时用Integer.MAX_VALUE表示正无穷，保证任何nums2的右半部分值都比它小
            //否则nums1右半部分的最小值是nums1[partitionX]（因为 nums1 是有序的，右半部分的第一个元素一个元素就是最小值）
            int minRX = partitionX == m ? Integer.MAX_VALUE:nums1[partitionX];

            //maxLY:nums2左半部分的最大值
            //如果partitionY == 0，表示nums2的左半部分为空，此时用Integer.MIN_VALUE表示负无穷，保证任何nums1的左半部分值都比它大
            //否则nums2左半部分的最大值是nums2[partitionY - 1]（因为 nums2 是有序的，左半部分的最后一个元素就是最大值）
            int maxLY = partitionY == 0 ? Integer.MIN_VALUE:nums2[partitionY-1];

            //minRY:nums2右半部分的最小值
            //如果partitionY == n，表示nums2的右半部分为空，此时用Integer.MAX_VALUE表示正无穷，保证任何nums1的右半部分值都比它小
            //否则nums2右半部分的最小值是nums2[partitionY]（因为 nums2 是有序的，右半部分的第一个元素一个元素就是最小值）
            int minRY = partitionY == n ? Integer.MAX_VALUE:nums2[partitionY];
            //检查 nums1 的左半部分的最大值是否小于等于 nums2 的右半部分的最小值
            if(maxLX<=minRY){
                //合并后的左半部分的最大值
                median1 = Math.max(maxLX,maxLY);
                //合并后的右半部分的最小值
                median2 = Math.min(minRX,minRY);
                //分割点太靠左，需要在nums1的右半部分继续搜索
                l = partitionX + 1;
            }else r = partitionX - 1;//分割点太靠右，需要在nums1的左半部分继续搜索
        }
        //返回中位数
        return (m+n)%2 == 0 ?(median1+median2)/2.0:median1;
    }
}