LeetCode#5 两个排序数组的中位数

 

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2 。

请找出这两个有序数组的中位数。要求算法的时间复杂度为 O(log (m+n)) 。

你可以假设 nums1 和 nums2 不同时为空。

示例 1:

nums1 = [1, 3] nums2 = [2]
中位数是 2.0

示例 2:

nums1 = [1, 2] nums2 = [3, 4]
中位数是 (2 + 3)/2 = 2.5

 

自我思路：

1.寻找出两个数组合并后中位数的位置

2.从小到大，从两个数组中取出对应位置的数

难点：

1.获取中位数的位置。本人对数字超级混乱，所以如何获取数组的中位数需要留意。

2.按元素大小，遍历两个有序数组的元素，并获取对应的中间的一个或两个数，从而获得中位数。

思路：从两个数组头部开始，比较元素大小，以A[m]和B[n]为例，则这两个长分别为m和n的数组的中位数位置应当是【（m+n-1）/2】或【（m+n-1）/2，（m+n-1）/2+1】。

（1）若A[0]>B[0]，则合并后数组的第一个元素是B[0]，反之则为A[0]。记为thisNum；

（2）以1中较大数继续与另一数组下一元素比较，获取thisNum。

（3）获取的thisNum是第【（m+n-1）/2】或【（m+n-1）/2，（m+n-1）/2+1】时，便记录下来求中位数。

3.从2的思路出发，可以实现算法的框架，但是会有一些细节问题：

（1）如何记录中位数的位数，是记录一个还是两个

（2）如何制定从小到大遍历数组的规则

算法实现：

 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Scanner;

 public class MedianSortedArrays {
     public static void main(String[] args) throws IOException{
         /*获取输入内容*/
         Scanner input = new Scanner(System.in);
         System.out.println("请输入第一个数组，元素间以逗号隔开：");
         int[] nums1=stringToArray(input.nextLine());
         System.out.println("请输入第二个数组，元素间以逗号隔开：");
         int[] nums2=stringToArray(input.nextLine());
         System.out.println("这两个数组的中位数是：");
         Solution getMedian=new Solution();
         Arrays.sort(nums1);
         Arrays.sort(nums2);
         double median=getMedian.findMedianSortedArrays(nums1,nums2);
         System.out.println(median);
     }

     /**
      * 将获取的字符串转为数组
      */
     public static int[] stringToArray(String str){
         String[] strArr= str.split(",");
         int[] arr=new int[strArr.length];
         for(int i=0;i<strArr.length;i++){
             arr[i]=Integer.parseInt(strArr[i].trim());
         }
         return arr;
     }
 }

 class Solution {
     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
         double midian;
         int[] index=getIndex(nums1.length+nums2.length);
         midian=getMedian(nums1,nums2,index);
         return midian;
     }

     /**
      * 获取中位数在组合后的数组中应当存在的位数
      * @param arrLength
      * @return
      */
     public int[] getIndex(int arrLength){
         int[] index =new int[2];
         index[0]=(arrLength-1)/2;//（数组长度-1）/2为中位数在有序数组中的下标之一
         if(arrLength%2==0){         //当数组长度为偶数，则中位数是（数组长度-1）/2和（数组长度-1）/2+1这两个下标对应元素的平均值
             index[1]=index[0]+1;
         }
         return index;
     }

     /**
      * 获取中位数
      * @param nums1
      * @param nums2
      * @param index        中位数下标对应数组[（数组长度-1）/2,（数组长度-1）/2+1]或[（数组长度-1）/2,0]
      * @return
      */
     public double getMedian(int[] nums1, int[] nums2,int[] index){
         double sum=0;        //记录中位数对应下标两个元素之和
         int maxIndex;        //记录中位数下标数组的较大数
         double indexLength;

         /*此处获取中位数最大下标作为循环标记*/
         if(index[1]==0){
             maxIndex=index[0];
             indexLength=1;
         }else{
             maxIndex=index[1];
             indexLength=2;
         }

         /*获取两个数组中的对应下标元素之和*/
         int j=0,k=0,thisIndex=0,thisNum = 0;
         while(thisIndex<=maxIndex){
             if(j<nums1.length&&k<nums2.length){ //当两个数组均可遍历时
                 if(nums1[j]>=nums2[k]){            //比较元素大小，当某一数组元素小，便推向该数组下一个元素
                     thisNum=nums2[k];            //记录比较所得的较小元素，作为thisNum
                     k++;
                 }else{
                     thisNum=nums1[j];
                     j++;
                 }
             }else{                                //当有数组遍历结束，但仍未找到中位数时
                 if(j==nums1.length){            //遍历完的数组不再参与thisNum的记录，只进行另外一个数组的遍历
                     thisNum=nums2[k];
                     k++;
                 }
                 if(k==nums2.length){
                     thisNum=nums1[j];
                     j++;
                 }
             }

             if(thisIndex==maxIndex){            //若遍历的次数达到中位数下标要求，便做和，记录中位数相关元素之和
                 sum+=thisNum;
             }
             if(index[1]!=0&&thisIndex==maxIndex-1){
                 sum+=thisNum;
             }

             thisIndex++;                        //遍历标记
         }
         return sum/indexLength;                    //返回中位数
     }
 }

本方案在leetCode提交后，结果运行时间为54ms，而LeetCode最快的结果是32ms

其代码如下

 class Solution {
     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
         int m = nums1.length, n = nums2.length, left = (m + n + 1) / 2, right = (m + n + 2) / 2;
         return (findKth(nums1, nums2, left) + findKth(nums1, nums2, right)) / 2.0;
     }
     int findKth(int[] nums1, int[] nums2, int k) {
         int m = nums1.length, n = nums2.length;
         if (m > n) return findKth(nums2, nums1, k);
         if (m == 0) return nums2[k - 1];
         if (k == 1) return Math.min(nums1[0], nums2[0]);
         int i = Math.min(m, k / 2), j = Math.min(n, k / 2);
         if (nums1[i - 1] > nums2[j - 1]) {
             return findKth(nums1, Arrays.copyOfRange(nums2, j, n), k - j);
         } else {
             return findKth(Arrays.copyOfRange(nums1, i, m), nums2, k - i);
         }
     }
 }

 

通过比较可以看得出来，

1.对问题分析的深度和细致还不够，更偏向于暴力破解

2.对递归算法的运用是没有认识的