Median of Two Sorted Array leetcode java


There are two sorted arrays A and B 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)). 

 

 题解:

首先我们先明确什么是median,即中位数。 

引用Wikipedia对中位数的定义:

计算有限个数的数据的中位数的方法是:把所有的同类数据按照大小的顺序排列。如果数据的个数是奇数,则中间那个数据就是这群数据的中位数;如果数据的个数是偶数,则中间那2个数据的算术平均值就是这群数据的中位数。

因此,在计算中位数Median时候,需要根据奇偶分类讨论。

解决此题的方法可以依照:寻找一个unioned sorted array中的第k大(从1开始数)的数。因而等价于寻找并判断两个sorted array中第k/2(从1开始数)大的数。

特殊化到求median,那么对于奇数来说,就是求第(m+n)/2+1(从1开始数)大的数。

而对于偶数来说,就是求第(m+n)/2大(从1开始数)和第(m+n)/2+1大(从1开始数)的数的算术平均值。


那么如何判断两个有序数组A,B中第k大的数呢?

我们需要判断A[k/2-1]和B[k/2-1]的大小。

如果A[k/2-1]==B[k/2-1],那么这个数就是两个数组中第k大的数。

如果A[k/2-1]<B[k/2-1], 那么说明A[0]到A[k/2-1]都不可能是第k大的数,所以需要舍弃这一半,继续从A[k/2]到A[A.length-1]继续找。当然,因为这里舍弃了A[0]到A[k/2-1]这k/2个数,那么第k大也就变成了,第k-k/2个大的数了。

如果 A[k/2-1]>B[k/2-1],就做之前对称的操作就好。

 这样整个问题就迎刃而解了。

 

当然,边界条件页不能少,需要判断是否有一个数组长度为0,以及k==1时候的情况。

 

因为除法是向下取整,并且页为了方便起见,对每个数组的分半操作采取:

int partA = Math.min(k/2,m);
int partB = k - partA; 

 为了能保证上面的分半操作正确,需要保证A数组的长度小于B数组的长度。

 

同时,在返回结果时候,注意精度问题,返回double型的就好。 

 

代码如下:

复制代码
 1  public  static  double findMedianSortedArrays( int A[],  int B[]) {
 2      int m = A.length;
 3      int n = B.length;
 4      int total = m+n;
 5      if (total%2 != 0)
 6          return ( double) findKth(A, 0, m-1, B, 0, n-1, total/2+1);//k传得是第k个,index实则k-1
 7      else {
 8          double x = findKth(A, 0, m-1, B, 0, n-1, total/2);//k传得是第k个,index实则k-1
 9          double y = findKth(A, 0, m-1, B, 0, n-1, total/2+1);//k传得是第k个,index实则k-1
10          return ( double)(x+y)/2;
11     }
12 }
13  
14  public  static  int findKth( int[] A,  int astart,  int aend,  int[] B,  int bstart,  int bend,  int k) {
15      int m = aend - astart + 1;
16      int n = bend - bstart + 1;
17     
18      if(m>n)
19          return findKth(B,bstart,bend,A,astart,aend,k);
20      if(m==0)
21          return B[k-1];
22      if(k==1)
23          return Math.min(A[astart],B[bstart]);
24     
25      int partA = Math.min(k/2,m);
26      int partB = k - partA;
27      if(A[astart+partA-1] < B[bstart+partB-1])
28          return findKth(A,astart+partA,aend,B,bstart,bend,k-partA);
29      else  if(A[astart+partA-1] > B[bstart+partB-1])
30          return findKth(A,astart,aend,B,bstart+partB,bend,k-partB);
31      else
32          return A[astart+partA-1];
33     }
复制代码



这道题比较直接的想法就是用 Merge Sorted Array 这个题的方法把两个有序数组合并,当合并到第(m+n)/2个元素的时候返回那个数即可,而且不用把结果数组存起来。算法时间复杂度是O(m+n),空间复杂度是O(1)。因为代码比较简单,就不写出来了,跟 Merge Sorted Array 比较类似,大家可以参照这个题目的解法。

接下来我们考虑有没有优化的算法。优化的思想来源于order statistics,在算法导论10.3节中提到。问题等价于求两个array的第k=(m+n)/2(假设m和n分别是两个数组的元素个数)大的数是多少。基本思路是每次通过查看两个数组的第k/2大的数(假设是A[k/2],B[k/2]),如果两个A[k/2]=B[k/2],说明当前这个数即为两个数组剩余元素的第k大的数,如果A[k/2]>B[k/2], 那么说明B的前k/2个元素都不是我们要的第k大的数,反之则排除A的前k/2个,如此每次可以排除k/2个元素,最终k=1时即为结果。总的时间复杂度为O(logk),空间复杂度也是O(logk),即为递归栈大小。在这个题目中因为k=(m+n)/2,所以复杂度是O(log(m+n))。比起第一种解法有明显的提高,代码如下: 

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public double findMedianSortedArrays(int A[], int B[]) {  
  2.     if((A.length+B.length)%2==1)  
  3.         return helper(A,B,0,A.length-1,0,B.length-1,(A.length+B.length)/2+1);  
  4.     else  
  5.         return (helper(A,B,0,A.length-1,0,B.length-1,(A.length+B.length)/2)    
  6.                +helper(A,B,0,A.length-1,0,B.length-1,(A.length+B.length)/2+1))/2.0;  
  7. }  
  8. private int helper(int A[], int B[], int i, int i2, int j, int j2, int k)  
  9. {  
  10.     int m = i2-i+1;  
  11.     int n = j2-j+1;  
  12.     if(m>n)  
  13.         return helper(B,A,j,j2,i,i2,k);  
  14.     if(m==0)  
  15.         return B[j+k-1];  
  16.     if(k==1)  
  17.         return Math.min(A[i],B[j]);  
  18.     int posA = Math.min(k/2,m);  
  19.     int posB = k-posA;  
  20.     if(A[i+posA-1]==B[j+posB-1])  
  21.         return A[i+posA-1];  
  22.     else if(A[i+posA-1]<B[j+posB-1])  
  23.         return helper(A,B,i+posA,i2,j,j+posB-1,k-posA);  
  24.     else  
  25.         return helper(A,B,i,i+posA-1,j+posB,j2,k-posB);  
  26. }  
实现中还是有些细节要注意的,比如有时候剩下的数不足k/2个,那么就得剩下的,而另一个数组则需要多取一些数。但是由于这种情况发生的时候,不是把一个数组全部读完,就是可以切除k/2个数,所以不会影响算法的复杂度。 
这道题的优化算法主要是由order statistics派生而来,原型应该是求topK的算法,这个问题是非常经典的问题,一般有两种解法,一种是用quick select(快速排序的subroutine),另一种是用heap。 复杂度是差不多的,有兴趣可以搜一下,网上资料很多,topK问题在海量数据处理中也是一个非常经典的问题,所以还是要重视。


归并计数法 Merge and Count

复杂度

时间O(n) 空间O(1)

思路

如果对时间复杂度没有要求,这个方法是实现起来最简单的,我们只需要从下往上依次数(n+m)/2个元素即可。由于两个数组都已经排序,我们可以使用两个指针指向数组“底部”,通过比较两个数组“底部”的元素大小来决定计哪一个元素,同时将其所在数组的指针“向上”移一位。为了方便处理总元素为偶数的情况,这里将找中位数变成找第k小的元素。

注意

  • 计数的循环是用来找到第k-1个元素的,最后return的时候再判断第k个元素是哪一个
  • 在每次计数的循环中要先判断两个数组指针是否超界,在最后return之前也要判断一次

代码

Javapublic class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int len1 = nums1.length;
        int len2 = nums2.length;
        int total = len1 + len2;
        if(total % 2==0){
            return (findKth(nums1,nums2,total/2)+findKth(nums1,nums2,total/2+1))/2.0;
        } else {
            return findKth(nums1,nums2,total/2+1);
        }
    }
    private int findKth(int[] nums1, int[] nums2, int k){
        int p = 0, q = 0;
        for(int i = 0; i < k - 1; i++){
            if(p>=nums1.length && q<nums2.length){
                q++;
            } else if(q>=nums2.length && p<nums1.length){
                p++;
            } else if(nums1[p]>nums2[q]){
                q++;
            } else {
                p++;
            }
        }
        if(p>=nums1.length) {
            return nums2[q];
        } else if(q>=nums2.length) {
            return nums1[p];
        } else {
            return Math.min(nums1[p],nums2[q]);
        }
    }
}

分治法 Divide and Conquer

复杂度

时间O(log(m+n)) 空间O(1)

思路

题目要求O(log(m+n))的时间复杂度,一般来说都是分治法或者二分搜索。首先我们先分析下题目,假设两个有序序列共有n个元素(根据中位数的定义我们要分两种情况考虑),当n为奇数时,搜寻第(n/2+1)个元素,当n为偶数时,搜寻第(n/2+1)和第(n/2)个元素,然后取他们的均值。进一步的,我们可以把这题抽象为“搜索两个有序序列的第k个元素”。如果我们解决了这个k元素问题,那中位数不过是k的取值不同罢了。

那如何搜索两个有序序列中第k个元素呢,这里又有个技巧。假设序列都是从小到大排列,对于第一个序列中前p个元素和第二个序列中前q个元素,我们想要的最终结果是:p+q等于k-1,且一序列第p个元素和二序列第q个元素都小于总序列第k个元素。因为总序列中,必然有k-1个元素小于等于第k个元素。这样第p+1个元素或者第q+1个元素就是我们要找的第k个元素。

所以,我们可以通过二分法将问题规模缩小,假设p=k/2-1,则q=k-p-1,且p+q=k-1。如果第一个序列第p个元素小于第二个序列第q个元素,我们不确定二序列第q个元素是大了还是小了,但一序列的前p个元素肯定都小于目标,所以我们将第一个序列前p个元素全部抛弃,形成一个较短的新序列。然后,用新序列替代原先的第一个序列,再找其中的第k-p个元素(因为我们已经排除了p个元素,k需要更新为k-p),依次递归。同理,如果第一个序列第p个元素大于第二个序列第q个元素,我们则抛弃第二个序列的前q个元素。递归的终止条件有如下几种:

  • 较短序列所有元素都被抛弃,则返回较长序列的第k个元素(在数组中下标是k-1)
  • 一序列第p个元素等于二序列第q个元素,此时总序列第p+q=k-1个元素的后一个元素,也就是总序列的第k个元素

注意

  • 每次递归不仅要更新数组起始位置(起始位置之前的元素被抛弃),也要更新k的大小(扣除被抛弃的元素)

代码

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

    }

    private double findKth(int[] arr1, int[] arr2, int start1, int start2, int len1, int len2, int k){
        if(len1>len2){
            return findKth(arr2,arr1,start2,start1,len2,len1,k);
        }
        if(len1==0){
            return arr2[start2 + k - 1];
        }
        if(k==1){
            return Math.min(arr1[start1],arr2[start2]);
        }
        int p1 = Math.min(k/2,len1) ;
        int p2 = k - p1;
        if(arr1[start1 + p1-1]<arr2[start2 + p2-1]){
            return findKth(arr1,arr2,start1 + p1,start2,len1-p1,len2,k-p1);
        } else if(arr1[start1 + p1-1]>arr2[start2 + p2-1]){
            return findKth(arr1,arr2,start1,start2 + p2,len1,len2-p2,k-p2);
        } else {
            return arr1[start1 + p1-1];
        }
    }
}

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值