算法题：寻找两个正序数组的中位数（题目+思路+代码注释解释）

题目

给定两个大小分别为 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
-106 <= nums1[i], nums2[i] <= 106

进阶：你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

• 首先对零个元素、一个元素、两个元素的情况做特殊处理，直接返回
• 其次对于两个正序数组总个数超过2个元素的情况做处理
• 既然是要寻找中位数，那么中位数分两种情况，做分类讨论，定义关键位置index=总个数/2（整数运算），第一种是总个数为奇数的情况，则直接取下标为index的数，而偶数个的情况取下标为index-1 和index的两个数的平均值。
• 题中写到时间复杂度为O(log (m+n))，那肯定不能直接两个数组合并再排序了。
• 那么我的思路是，比如5个数要找第三个，那我就从两个数组里拿头一个的值，每次从两个数组里拿一个最小的，反正本来就是有序的，我只需要从两个数组里去最小值，每次取一个，取到中位数下标的时候我就返回结果即可
• 比如
• 1 6
• 2 3 4
• index=(2+3)/2=2 p=0
• 第一次取得1 p=1 第二次取得2 p=2 跳出循环 拿值取得3返回
• 1 6
• 2 3 4 5
• index=(2+4)/2=3 p=0
• 第一次取得1 p=1 第二次取得2 p=2 第三次取得3 p=3 跳出循环
• 使用上一次取得的数加下一次取得的数求平均值返回即可
• 返回（3+4）/2=3.5 （注意，计算要用double）

代码实现

class Solution {
    /**
     * 两个数组取数，上次取完数的下标
     */
    private  int i=-1,j=-1;


    public  double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int len=nums1.length+nums2.length;
        //三种特殊情况直接返回
        if (len==0){
            return 0;
        }
        if (len==1){
            return nums1.length==1?nums1[0]:nums2[0];
        }
        if (len==2){
            double sum=0;
            for (int i:nums1){
                sum+=i;
            }
            for (int i:nums2){
                sum+=i;
            }
            return sum/2;
        }
        //直接从左开始数，找到中位数，总个数奇数拿一个，偶数拿两个，到了中位数的时候记下来，然后就返回数据，不用再排序，左右两个集合反正优先拿最小的出来，计数+1
        int position=len/2,p=0;
        //是不是只取一个？（奇数只需要取最中间的一个，偶数要取两个）
        boolean one=true;
        if (len%2==0){
            one=false;
        }
        //返回的值的和
        double sum=0;
        //跳出循环前最后取的值（偶数需要）
        int last=0;
        while (p!=position){
            //位置+1，并取一次值
            p++;
            last=peekMinOne(nums1,nums2);
        }
        //奇数则直接用下一个取到的值
        if (one){
            sum=peekMinOne(nums1,nums2);
        }else {
            //偶数等于上一个值加下一个值的平均值
            sum+=last;
            sum+=peekMinOne(nums1,nums2);
            sum/=2;
        }
        return sum;
    }

    int peekMinOne(int[] nums1,int[] nums2){
        //第一个数组第二个数组是否还可以从里面拿数据
        boolean has1=false,has2=false;
        int len1=nums1.length,len2=nums2.length;
        //数组没有越界
        if (i+1<len1){
            //第一个数组还可以取数
            has1=true;
        }
        //数组没有越界
        if (j+1<len2){
            //第一个数组还可以取数
            has2=true;
        }
        
        if (has1){
            //第一个数组还可以取数
            if (has2){
                //第二个数组还可以取数
                if (nums1[i+1]<nums2[j+1]){
                    //第一个数组取到的数比第二个数组取到的数小，则第一个数组取数标志位i 加一，并取这个位置上的数返回
                    i++;
                    return nums1[i];
                }else {
                    //第二个数组取到的数比第一个数组取到的数小，则第二个数组取数标志位j 加一，并取这个位置上的数返回
                    j++;
                    return nums2[j];
                }
            }else {
                //第二个数组没有数了，直接返回第一个数组的可取到的最小数，取数位置i 加1
                i++;
                return nums1[i];
            }
        }else {
            //第一个数组没有数可以取了
            if (has2){
                //第二个数组有数可以取，第二个数组的取数标志位j 加一，并返回这个位置上的数
                j++;
                return nums2[j];
            }
        }
        return 0;
    }
}