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

一、题目

 

二、我的解题代码 

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if (nums1.length==0){
            if (nums2.length%2==0){
                return (double)(nums2[nums2.length/2-1]+nums2[nums2.length/2])/2;
            }else {
                return nums2[nums2.length/2];
            }
        }
        if (nums2.length==0){
            if (nums1.length%2==0){
                return (double)(nums1[nums1.length/2-1]+nums1[nums1.length/2])/2;
            }else {
                return nums1[nums1.length/2];
            }
        }


        int[] arr=new int[nums1.length+nums2.length];
        for(int i=0;i<nums1.length;i++){
            arr[i]=nums1[i];
        }
        for(int i=0;i<nums2.length;i++){
            arr[i+nums1.length]=nums2[i];
        }

        for(int i=0;i<nums2.length;i++){
            for(int j=0;j<nums1.length+i;j++){
                if(nums2[i]<=arr[j]){
                    exch(arr,nums2[i],j);
                    break;
                }else if(j==nums1.length+i-1){
                    exch(arr,nums2[i],j+1);
                }
            }
        }

        if((nums1.length+nums2.length)%2==0){
            return (double)(arr[(nums1.length+nums2.length)/2-1]+arr[(nums1.length+nums2.length)/2])/2;
        }
        return arr[(nums1.length+nums2.length)/2];
    }

    public static void exch(int[] arr,int i,int j){
        for(int k=arr.length-1;k>j;k--){
            arr[k]=arr[k-1];
        }
        arr[j]=i;
    }
}

 可以看出代码臃肿繁杂，效率低下，水平有待提高！

三、参考别人的 

 

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int length1 = nums1.length;
        int length2 = nums2.length;
        int totalLength = length1 + length2;
        boolean odd = totalLength % 2 == 1;
        if (length1 > length2) return findMedianSortedArrays(nums2, nums1);
        //如果当前nums1里面没有内容，则代表无论左半数据和右半数据都位于nums2中
        if (nums1.length == 0) {
            if (odd) {
                return nums2[(length2 + 1) / 2 - 1];
            } else {
                return (nums2[length2 - 1] + nums2[0]) / 2.0;
            }
        }
        //如果当前num1的最小值大于等于nums2的最大值，说明左值必然全部分布在nums2中
        if (nums1[0] >= nums2[length2 - 1]) {
            int middle = (totalLength + 1) / 2;
            if (odd) {
                return nums2[middle - 1];
            } else {
                if (middle >= length2) return (nums2[middle - 1] + nums1[0]) / 2.0;
                else return (nums2[middle - 1] + nums2[middle]) / 2.0;
            }
        }
        //如果当前num1最大值小于num2最小值，
        //意外着当前num1所有值都小于num2的内容
        //进而num1所有值均为中位值的左侧数据
        if (nums1[length1 - 1] <= nums2[0]) {
            //java特性，取整
            int middle = (totalLength + 1) / 2;
            int remainQty = middle - length1;
            //如果没有剩余，则代表中间值为num1的最大值，通过总长度奇偶判定，
            //如果是奇数，取当前值，如果是偶数，取num1最大值和num2最小值
            if (remainQty == 0) {
                if (odd) {
                    return nums1[length1 - 1];
                } else {
                    return (nums1[length1 - 1] + nums2[0]) / 2.0;
                }
            } else {
                //如果是奇数，取当前值，
                //之所以采用remainQty - 1是因为数组下标为约定数组取值取（长度 - 1）位置的数据
                if (odd) {
                    return nums2[remainQty - 1];
                } else {
                    return (nums2[remainQty - 1] + nums2[remainQty]) / 2.0;
                }
            }
        } else {
            //但凡不满足条件1所述场景，则意味着进入混合组数的场景，即
            //中值左边的数据会从num1和num2中各分出一部分
            //采用二分查找法定位第一个分割位置

            //设置二分查找的左边和二分查找的右边
            int start = 0;
            int end = length1;
            while (start <= end) {
                //定位到此时start和end的中间值，判定当前start到middle这几个数是不是我现在所需要的左值内容
                int middle = (start + end) / 2;
                //假设当前middle对应的值为我所需要的存在与num1中的左值内容，则剩余的左值内容均为num2中前remainQty个元素
                int remainQty = (totalLength + 1) / 2 - middle;
                int l1 = middle == 0 ? Integer.MIN_VALUE : nums1[middle - 1];
                int l2 = remainQty == 0 ? Integer.MIN_VALUE : nums2[remainQty - 1];
                int r1 = middle == length1 ? Integer.MAX_VALUE : nums1[middle];
                int r2 = remainQty == length2 ? Integer.MAX_VALUE : nums2[remainQty];
                if (l1 > r2)
                    //middle - 1代表取middle左边一个顺位的值
                    end = middle - 1;
                else if (l2 > r1)
                    //middle + 1代表取middle右边一个顺位的值
                    start = middle + 1;
                else {
                    int first = Math.max(l1, l2);
                    int second = Math.min(r1, r2);
                    if (odd) {
                        return first;
                    } else {
                        return (first + second) / 2.0;
                    }
                }
            }
        }
        return 0.0;
    }
}

这个时间复杂度极低，速度很快不过代码好多