两个排序数组的中位数

  1 import java.io.IOException;
  2 import java.util.Arrays;
  3 import java.util.Scanner;
  4 
  5 public class MedianSortedArrays {
  6     public static void main(String[] args) throws IOException{
  7         /*获取输入内容*/
  8         Scanner input = new Scanner(System.in);
  9         System.out.println("请输入第一个数组，元素间以逗号隔开：");
 10         int[] nums1=stringToArray(input.nextLine());
 11         System.out.println("请输入第二个数组，元素间以逗号隔开：");
 12         int[] nums2=stringToArray(input.nextLine());
 13         System.out.println("这两个数组的中位数是：");
 14         Solution getMedian=new Solution();
 15         Arrays.sort(nums1);
 16         Arrays.sort(nums2);
 17         double median=getMedian.findMedianSortedArrays(nums1,nums2);
 18         System.out.println(median);
 19     }
 20 
 21     /**
 22      * 将获取的字符串转为数组
 23      */
 24     public static int[] stringToArray(String str){
 25         String[] strArr= str.split(",");
 26         int[] arr=new int[strArr.length];
 27         for(int i=0;i){
 28             arr[i]=Integer.parseInt(strArr[i].trim());
 29         }
 30         return arr;
 31     }
 32 }
 33 
 34 
 35 class Solution {
 36     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
 37         double midian;
 38         int[] index=getIndex(nums1.length+nums2.length);
 39         midian=getMedian(nums1,nums2,index);
 40         return midian;
 41     }
 42     
 43     /**
 44      * 获取中位数在组合后的数组中应当存在的位数
 45      * @param arrLength
 46      * @return
 47      */
 48     public int[] getIndex(int arrLength){
 49         int[] index =new int[2];
 50         index[0]=(arrLength-1)/2;//（数组长度-1）/2为中位数在有序数组中的下标之一
 51         if(arrLength%2==0){         //当数组长度为偶数，则中位数是（数组长度-1）/2和（数组长度-1）/2+1这两个下标对应元素的平均值
 52             index[1]=index[0]+1;
 53         }
 54         return index;
 55     }
 56     
 57     /**
 58      * 获取中位数
 59      * @param nums1
 60      * @param nums2
 61      * @param index        中位数下标对应数组[（数组长度-1）/2,（数组长度-1）/2+1]或[（数组长度-1）/2,0]
 62      * @return
 63      */
 64     public double getMedian(int[] nums1, int[] nums2,int[] index){
 65         double sum=0;        //记录中位数对应下标两个元素之和
 66         int maxIndex;        //记录中位数下标数组的较大数
 67         double indexLength;
 68         
 69         /*此处获取中位数最大下标作为循环标记*/
 70         if(index[1]==0){
 71             maxIndex=index[0];
 72             indexLength=1;
 73         }else{
 74             maxIndex=index[1];
 75             indexLength=2;
 76         }
 77         
 78         /*获取两个数组中的对应下标元素之和*/
 79         int j=0,k=0,thisIndex=0,thisNum = 0;
 80         while(thisIndexmaxIndex){
 81             if(j//当两个数组均可遍历时
 82                 if(nums1[j]>=nums2[k]){            //比较元素大小，当某一数组元素小，便推向该数组下一个元素
 83                     thisNum=nums2[k];            //记录比较所得的较小元素，作为thisNum
 84                     k++;
 85                 }else{
 86                     thisNum=nums1[j];
 87                     j++;
 88                 }
 89             }else{                                //当有数组遍历结束，但仍未找到中位数时
 90                 if(j==nums1.length){            //遍历完的数组不再参与thisNum的记录，只进行另外一个数组的遍历
 91                     thisNum=nums2[k];
 92                     k++;
 93                 }
 94                 if(k==nums2.length){
 95                     thisNum=nums1[j];
 96                     j++;
 97                 }
 98             }
 99             
100             if(thisIndex==maxIndex){            //若遍历的次数达到中位数下标要求，便做和，记录中位数相关元素之和
101                 sum+=thisNum;
102             }
103             if(index[1]!=0&&thisIndex==maxIndex-1){
104                 sum+=thisNum;
105             }
106 
107             thisIndex++;                        //遍历标记
108         }
109         return sum/indexLength;                    //返回中位数
110     }
111 }

 1 class Solution {
 2     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
 3         int m = nums1.length, n = nums2.length, left = (m + n + 1) / 2, right = (m + n + 2) / 2;
 4         return (findKth(nums1, nums2, left) + findKth(nums1, nums2, right)) / 2.0;
 5     }
 6     int findKth(int[] nums1, int[] nums2, int k) {
 7         int m = nums1.length, n = nums2.length;
 8         if (m > n) return findKth(nums2, nums1, k);
 9         if (m == 0) return nums2[k - 1];
10         if (k == 1) return Math.min(nums1[0], nums2[0]);
11         int i = Math.min(m, k / 2), j = Math.min(n, k / 2);
12         if (nums1[i - 1] > nums2[j - 1]) {
13             return findKth(nums1, Arrays.copyOfRange(nums2, j, n), k - j);
14         } else {
15             return findKth(Arrays.copyOfRange(nums1, i, m), nums2, k - i);
16         }
17     }
18 }