Median of Two Sorted Arrays-leetcode4 Three different methods

There are two sorted arrays nums1 and nums2 of size m and n respectively.

Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

You may assume nums1 and nums2 cannot be both empty.

Example 1:

nums1 = [1, 3]
nums2 = [2]

The median is 2.0
Example 2:

nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

solution 1
// space complexity: 0(m+n)
// time complexity: 0(m+n+log(m+n))

// space complexity: 0(m+n)
// time complexity: 0(m+n+log(m+n))
class Solution {
    public double findMedianSortedArrays(int[] arr1, int[] arr2) {
        int []arr=new int[arr1.length+arr2.length];
        int idx=0;
        for(int i=0;i<arr1.length;i++){
            arr[idx]=arr1[i];
            idx++;
        }
         for(int i=0;i<arr2.length;i++){
            arr[idx]=arr2[i];
            idx++;
        }
        Arrays.sort(arr);
        if(arr.length%2==0){
            int first=arr[arr.length/2];
            int second=arr[(arr.length-1)/2];
            return ((double)(first+second)/2);
            
        }
        else{
          return (double)arr[arr.length/2]  ;
        }
          
    }
}

solution 2: time complexity O(m+n)

class Solution {
    public double findMedianSortedArrays(int[] a, int[] b) {
        int[] mergedArray= mergeArrays(a, b);
        int n=a.length+b.length;
        
        for(int i=0; i<n; i++){
            System.out.println(mergedArray[i]);
        }
        
        if(n%2==0) return ((double)mergedArray[(n-1)/2]+(double)mergedArray[n/2])/2;
        else return mergedArray[n/2];
        
    }
    
    public int[] mergeArrays(int[] a, int[] b){
        int[] merged=new int[a.length+b.length];
        int i=0, j=0, k=0;
        while( i<a.length && j<b.length){
            if(a[i]<=b[j]){
                merged[k]=a[i];
                i++;
                k++;
            }
            else{
                merged[k]=b[j];
                j++;
                k++;
                
            }
        }
        
        while(i<a.length){
                merged[k]=a[i];
                i++;
                k++;            
        }
        
        while(j<b.length){
                merged[k]=b[j];
                j++;
                k++;            
        }
        
        return merged;
    }
}

Simple version:

class Solution {
    public double findMedianSortedArrays(int[] a, int[] b) {
        int[] mergedArray= mergeArrays(a, b);
        int n=a.length+b.length;
               
        if(n%2==0) return ((double)mergedArray[(n-1)/2]+(double)mergedArray[n/2])/2;
        else return mergedArray[n/2];   
    }
    
    public int[] mergeArrays(int[] a, int[] b){
        int[] merged=new int[a.length+b.length];
        int i=0, j=0, k=0;
        while( i<a.length && j<b.length){
            merged[k++]=(a[i]<=b[j])? a[i++] : b[j++];
        }
        
        while(i<a.length){
                merged[k++]=a[i++];         
        }
        
        while(j<b.length){
                merged[k++]=b[j++];       
        }
        
        return merged;
    }
}

Solution 3

time complexity O(log m)

class Solution {
    public double findMedianSortedArrays(int[] a, int[] b) {
        if(a.length>b.length) return findMedianSortedArrays(b, a);
        if(a.length==0) return ((double) b[(b.length-1)/2]+(double) b[b.length/2] )/2.0;
        int lTotal=a.length+b.length;
        int aStart=0, aEnd=a.length;
        int aCut, bCut;
        
        while(aStart<=aEnd){
            aCut=(aStart+aEnd)/2;
            bCut=(lTotal+1)/2-aCut; //careful
            double L1=(aCut==0)? Integer.MIN_VALUE: a[aCut-1];
            double L2=(bCut==0)? Integer.MIN_VALUE: b[bCut-1];
            double R1=(aCut==a.length)? Integer.MAX_VALUE: a[aCut];
            double R2=(bCut==b.length)? Integer.MAX_VALUE: b[bCut];
            
            if(L1>R2) {aEnd=aCut-1;}
            else if(L2>R1) {aStart=aCut+1;}
            else{
                if(lTotal%2==0) return(Math.max(L1, L2)+Math.min(R1, R2))/2;
                else{ return Math.max(L1,L2);}
            }
        }
        return -1;
 
    }
}