有三种方法,时间复杂度分别是O(m+n) ,O(k),O(log(m+n))
注意点:
判断合并后的数组的元素个数是奇数还是偶数
如果是奇数取中间值;如果是偶数取中间2个数的平均值。
两种求中位数的方法:
方法1,判断奇数个还是偶数个
if (lengthall % 2 == 0){
result = ( all[lengthall/2-1] + all[lengthall/2] )*1.0/2;
}else{
result = all[lengthall/2];
}
方法2,不需要判断奇数个还是偶数个
int l = (lengthall+1)/2-1;
int r = (lengthall+2)/2-1;
//上面减1的原因是坐标从0开始的
result = (all[l] + all[r])*1.0/2;
//这种求中位数的方法不需要判断是奇数还是偶数个
思考:
中位数相当于合并之后的top(n/2),如果是其他top数也是可以的。所以如果是一个无序数组的top k就只用小顶堆。如果是两个有序数组合并之后的top k就可以用如下的方法。
(1)O(m+n)合并两有序数组成一个新有序数组,再按中间位置取值。
两个有序数组合并为一个有序数组的时间复杂度O(m+n)。请参考https://blog.csdn.net/fkyyly/article/details/83145276
/**1
* O(m+n)
* 合并两有序数组成一个新有序数组,再按中间位置取值
* @param nums1
* @param nums2
* @return
*/
public static double findMedianSortedArrays1(int[] nums1, int[] nums2) {
int length1 = nums1.length;
int length2 = nums2.length;
int lengthall = length1 + length2;
int[] all = new int[length1+length2];
int i=0,j=0,k=0;
while (i<length1 && j <length2){
if(nums1[i]<nums2[j]){
all[k]=nums1[i];
i++;
k++;
}else{
all[k] = nums2[j];
j++;
k++;
}
}
while (i<length1){
all[k]=nums1[i];
i++;
k++;
}
while (j<length2){
all[k] = nums2[j];
j++;
k++;
}
double result;
if (lengthall % 2 == 0){
result = ( all[lengthall/2-1] + all[lengthall/2] )*1.0/2;
}else{
result = all[lengthall/2];
}
return result;
}
(2)O(k)两个指针分别从两数组开头指,比较两指针处的数,谁小谁往后移,直到两指针共移动k次,k为中间位置
/**2
* O(k)
* 两个指针分别从两数组开头指,比较两指针处的数,谁小谁往后移,
* 直到两指针共移动k次,k为中间位置
* 注意总数有奇数个还是偶数个计算中位数的方法
* @param nums1
* @param nums2
* @return
*/
public static double findMedianSortedArrays2(int[] nums1, int[] nums2) {
int length1 = nums1.length;
int length2 = nums2.length;
int lengthall = length1 + length2;
int inx1 = 0;
int inx2 = 0;
int x = -1;
int y = -1;
while (inx1 + inx2 < lengthall){
if (inx1 < length1) {
while (inx2 == length2 || nums1[inx1] <= nums2[inx2] ) {
//nums1到头了或者nums1此时的元素小于nums2此时的元素,这两种情况下从nums1取值(也就是nums1和nums2小的移动)
inx1++;
//下面是总长度是奇数还是偶数对于中位数的计算
if (inx1 + inx2 == (lengthall + 1) / 2) {
x = nums1[inx1 - 1];
}
if (inx1 + inx2 == (lengthall + 2) / 2) {
y = nums1[inx1 - 1];
return (x + y) * 1.0 / 2;
}
if (inx1 == length1){
break;
}
}
}
if (inx2 < length2){
while ( inx1 == length1 || nums2[inx2] <= nums1[inx1] ) {
inx2++;
if (inx1 + inx2 == (lengthall + 1)/2){
x = nums2[inx2-1];
}
if (inx1 + inx2 == (lengthall + 2)/2){
y = nums2[inx2-1];
return (x+y)*1.0/2;
}
if (inx2 == length2){
break;
}
}
}
}
return -1;
}
(3)O(log(m+n))两个数组分别采用二分法查找
思想:上面的是数组num1[],下面是数组num2[]。
使用递归的思想分别对num1和num2求中位数,因为是有序的,所以直接取n/2处的值即可。
有个前提:合并后数组的中位数一定大于等于单个数组的中位数。
(1)如果num1的中位数=num2的中位数,那么就是最终的结果。
(2)如果num1的中位数<num2的中位数,那么下次就在[B,C]和[D,F]两个新数组直接找中位数。
(3)如果num1的中位数>num2的中位数,那么下次就在[A,C]和[E,F]两个新数组直接找中位数。
(4)重复这个步骤,直到新数组的长度为2
方法:二分+递归
--看到有序,并且明确要求时间复杂度为log级的,肯定需要二分。但是请注意,很多人一看到二分,就想也不想的开始对数组进行二分,但是对于这题,对数组二分就进了死胡同了。这题是对另一个量进行二分。
--再分析中位数的特征,就是求数组中的某一个(或两个)数,其左右两边的个数相等
--设两个有序数组分别为,a,长度m;b,长度n
--那么这个中位数,就是,a和b合并后的第(m+n+1)/2个(先不管有2个中位数的情况,后面会有个小技巧来屏蔽奇偶差异)
--那么现在的问题就变成了,求两个有序数组中,从小到大的第k个值
--所以二分其实是对k进行二分,两个数组同时从0开始,每次往后跳k/2个,当然不是同时跳,谁更小才能跳,保证已经跳过的数在整个数组中是最小的
private int findKth(int[] array1, int start1, int end1, int[] array2, int start2, int end2, int k){
if(start1>end1){
return array2[start2+k-1];
}
if(start2>end2){
return array1[start1+k-1];
}
if(k==1){
return Math.min(array1[start1], array2[start2]);
}
int mid1=Integer.MAX_VALUE;
int mid2=Integer.MAX_VALUE;
//这里的思想,其实不是每次移动整个end-start的一半,而是移动k的一半
if(start1+k/2-1<=end1){
mid1=array1[start1+k/2-1];
}
if(start2+k/2-1<=end2){
mid2=array2[start2+k/2-1];
}
if(mid1<mid2){
return findKth(array1, start1+k/2, end1, array2, start2, end2, k-k/2);
}
return findKth(array1, start1, end1, array2, start2+k/2, end2, k-k/2);
}
public double findMiddle(int[] array1, int[] array2){
int totalLength=array1.length+array2.length;
if(totalLength==0){
return -1;
}
//屏蔽奇偶差异,当是奇数时,k1,k2找到的是同一个中位数;当是偶数时,k1,k2找到的是两个中位数
int k1=(totalLength+1)/2;
int k2=(totalLength+2)/2;
int mid1, mid2;
if(array1.length==0){
mid1=array2[k1-1];
mid2=array2[k2-1];
}else if(array2.length==0){
mid1=array1[k1-1];
mid2=array1[k2-1];
}else {
mid1=findKth(array1, 0, array1.length-1, array2, 0, array2.length-1, k1);
mid2=findKth(array1, 0, array1.length-1, array2, 0, array2.length-1, k2);
}
return (double) (mid1+mid2)/2;
}
public static void main(String[] args) {
int[] nums1 = {1,2,3};
int[] nums2 = {3,4,5,6,7};
MediaTwoArr mediaTwoArr = new MediaTwoArr();
System.out.println(mediaTwoArr.findMiddle(nums1, nums2));
}
如果数组a的中位数小于数组b的中位数,那么整体的中位数只可能出现在a的右区间加上b的左区间之中;
如果数组a的中位数大于等于数组b的中位数,那么整体的中位数只可能出现在a的左区间加上b的右区间之中。
关键就是利用分治的思想逐渐缩小a的区间和b的区间来找到中位数。
首先假设数组A和B的元素个数都大于k/2,我们比较A[k/2-1]和B[k/2-1]两个元素,这两个元素分别表示A的第k/2小的元素和B的第k/2小的元素。这两个元素比较共有三种情况:>、<和=。如果A[k/2-1]<B[k/2-1],这表示A[0]到A[k/2-1]的元素都在A和B合并之后的前k小的元素中。换句话说,A[k/2-1]不可能大于两数组合并之后的第k小值,所以我们可以将其抛弃。
当A[k/2-1]>B[k/2-1]时存在类似的结论。
当A[k/2-1]=B[k/2-1]时,我们已经找到了第k小的数,也即这个相等的元素,我们将其记为m。由于在A和B中分别有k/2-1个元素小于m,所以m即是第k小的数。(这里可能有人会有疑问,如果k为奇数,则m不是中位数。这里是进行了理想化考虑,在实际代码中略有不同,是先求k/2,然后利用k-k/2获得另一个数。)
通过上面的分析,我们即可以采用递归的方式实现寻找第k小的数。此外我们还需要考虑几个边界条件:
如果A或者B为空,则直接返回B[k-1]或者A[k-1];
如果k为1,我们只需要返回A[0]和B[0]中的较小值;
如果A[k/2-1]=B[k/2-1],返回其中一个;
https://blog.csdn.net/hjhjhx26364/article/details/80251675
https://blog.csdn.net/darminz/article/details/77500474