LeetCode(3) || Median of Two Sorted Arrays

LeetCode(3) || Median of Two Sorted Arrays

题记

之前做了3题，感觉难度一般，没想到突然来了这道比较难的，星期六花了一天的时间才做完，可见以前基础太差了。

题目内容

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)).

解题思路

• 题目大致意思，有两个已经有序的数组A和B，他们的长度分别是m和n，现在要求获取两个数组的中位数且计算复杂度在O(log(m+n)).
• 题目意思比较简单，咋一想很好做么，但是考虑到时间复杂度O(log(m+n))的限制就略微有点困难了。
• 此题的难点主要在两个，一是计算复杂度，二是需要考虑很多边界情况，我在解题中就差点被淹没在无穷的边界情况中。
• 解此题我分别使用了三种方法，分别对应三种计算复杂度，O(nlog(n)),O(n),以及O(n)
  • 第一种方法O(nlog(n))是最简单，大多数人使用的，即将数组A和数组B合并成数组C，对C进行排序再求中位数。按理说这样复杂度应该不符合题目的要求的，但是我抱着不死心的态度去LeetCode尝试了下，没想到就通过了。由此可见，LeetCode的运算时间并没有想象中的那么严格。
  • 第二种方法O(n+m)需要进行一次遍历，在遍历的过程中，比较A[k]和B[i]，以从小到大顺序为例，如果A[k]<B[i]则K++，否则i++。一直到k+i达到中位数的要求。此算法的难度在于需要考虑多种边界条件。
  • 第三种方法O(log(m+n))，其实看到这个复杂度第一个反应就是对半查找，尝试了好久并未成功，后来才觉悟其实应该K值查找方法。算法内容大致如下：
    • 判断中位数的类型，即m+n若为奇数，则查找第(m+n)/2个数，否则查找第(m+n)/2和第(m+n)/2+1个数。需要考虑数组为空的情况。
    • 此时开始K值查找：

• • • K值查到其实就是查找第K个值的过程分解为查找第Min(K/2,m)和K-Min(K/2,m)两步，然后再递归进行下去。所以计算复杂度在O(log(m+n)).
    • 另外需要注意的是还需要考虑几种边界条件：
      • K=1时候，返回Min(A[0],B[0])
      • m=0时候，返回B[k-1]
      • m>n时候，需要互换数组A和数组B的位置。

解题方法

方法1：计算复杂度O(n*log(n))

 public class Solution {
     public double findMedianSortedArrays(int A[], int B[]) {
         int m = A.length;
         int n = B.length;
         int[] C = new int[m+n];
         double median = 0;
         System.arraycopy(A, 0, C, 0, A.length);
         System.arraycopy(B, 0, C, A.length, B.length);
         Arrays.sort(C);

         if ( (m + n) % 2 == 0 ) {
             median = (double)(C[(m+n)/2]+C[(m+n)/2-1])/2.0;
         }else{
             median = C[(m+n-1)/2];
         }

         return median;
     }
 }

方法2：计算复杂度O(n)

 public class Solution {
     public double findMedianSortedArrays(int A[], int B[]) {
         int m = A.length;
         int n = B.length;
         int medianIndex1 = (m + n) % 2 == 0 ? (m+n)/2-1 :(m+n-1)/2;
         int medianIndex2 = (m + n) % 2 == 0 ? (m+n)/2   :(m+n-1)/2;
         int travelA = 0;
         int travelB = 0;
         double median = 0;
         double median1 = 0;
         double median2 = 0;
         if ( m == 0 ){
             return n % 2 == 0 ? (double)(B[n/2]+B[n/2-1])/2:B[(n-1)/2];
         }

         if( n == 0 ){
             return m % 2 == 0 ? (double) (A[m/2]+A[m/2-1])/2:A[(m-1)/2];
         }

         for(int i = 0; i <= medianIndex2;i++){
             boolean flagA = true;
             if ( travelA < m && travelB < n){
                 if(A[travelA] >= B[travelB]){
                     flagA = false;
                 }else{
                     flagA = true;
                 }
             }else if ( travelA >= m){
                 flagA = false;
             }else{
                 flagA = true;
             }

             if (flagA){
                 if ( i == medianIndex1 ){
                     median1 = A[travelA];
                 }

                 if ( i == medianIndex2 ){
                     median2 = A[travelA];
                 }
                 travelA++;
             }else{
                 if ( i == medianIndex1 ){
                     median1 = B[travelB];
                 }

                 if ( i == medianIndex2 ){
                     median2 = B[travelB];
                 }
                 travelB++;
             }
         }

         if ( (m + n) % 2 == 0){
             median = (double) (median1 + median2)/2;
         }else{
             median = median1;
         }

         return median;
     }
 }

方法3：计算复杂度O(log(m+n))

    /**
      * int A[] B[] ，数组A和数组B.
      * int startA startB,子数组指针，子数组起始位置.
      * int K, 需要查找的第K个值
      * */
     public double findKthNum(int A[],int startA,int B[],int startB, int k){
         //获取数组A和数组B的子数组的数组长度
         int m = A.length - startA;
         int n = B.length - startB;
         //假设数组A短于数组B，否则数组A和数组B互换位置。
         if ( m > n){
             return findKthNum(B,startB,A,startA,k);
         }
         //数组A为空，第K个值从数组B的子串中获取
         if ( m == 0 ){
             return B[startB+k-1];
         }
         //只获取第一个数组，在数组A和数组B的子数组的第一个元素选择
         if ( k == 1 ){
             return A[startA] > B[startB] ? B[startB] : A[startA];
         }
         //将K值查找，分为min(k/2,m)和K-min(k/2,m)两步，考虑K/2>m这种情况
         int newK = Math.min(k/2,m);
         int leftK = k - newK;

         if ( A[startA+newK-1] < B[startB+leftK-1] ){
             //数组A的子数组的前newK个元素都在K值范围内，过滤这new个元素继续查找第leftK个值
             return findKthNum(A,startA+newK,B,startB,leftK);
         }else if (A[startA+newK-1] > B[startB+leftK-1]){
             //数组B的子数组的前leftK个元素都在K值范围内，过滤这leftK个元素继续查找第k-leftK个值
             return findKthNum(A,startA,B,startB+leftK,k-leftK);
         }else{
             //如果相等，则说明找到中位数
             return A[startA+newK-1];
         }
     }

     public double findMedianSortedArrays(int A[], int B[]) {
         int m = A.length;
         int n = B.length;
         if ( m == 0 ){
             //数组A为空，则在数组B内直接查找中位数
             return n % 2 == 0 ? (double)(B[n/2]+B[n/2-1])/2:B[(n-1)/2];
         }

         if( n == 0 ){
             //数组B为空，则在数组A内直接查找中位数
             return m % 2 == 0 ? (double) (A[m/2]+A[m/2-1])/2:A[(m-1)/2];
         }

         if ( (m + n) %2 != 0){
             //m+n为奇数，查找第(m+n)/2+1个数
             return findKthNum(A,0,B,0,(m+n)/2+1);
         }else{
             //m+n为偶数，查找第(m+n)/2合(m+n)/2+1个数
             return ((double) (findKthNum(A,0,B,0,(m+n)/2) + findKthNum(A,0,B,0,(m+n)/2+1)))/2;
         }
     }