两个有序数组中找中位数或者第K大的元素

RT,在两个有序数组中找中位数或者第K大的元素.

假设两个数组为A, B长度分别为m,n.分别是递增顺序。

可以采用的算法有很多:

首先想到的是类似MergeSort的方式,合并的同时找第K大元素,这个基本没难度,复杂度O(m + n)。

不过此算法并不是最优,还有Log级别复杂度的算法,此算法其实很简单,远没有很多网站的代码那么玄乎,以下一一道来:

首先明白几个前提:

1.如果是求中位数,(m + n)是奇数还是偶数对结果是很有影响的,具体的如果(m + n)是奇数,中位数唯一,如果是偶数就有两个中位数,怎么取舍就看要求了。

2.如果找到的第k大数(中位数类似)是 X ,如果X排在A中的 第Ax位置,X排序在B中的Bx位置,那么(Ax + Bx - 1) == k 是恒成立的。

明白了2中的前提后,我们就可以得到一个算法,在A数组中枚举X,加入在A中是第Ax个,那么可以反推B中第 (k + 1 - Ax)个以及相邻元素和X的大小关系就可以得到一个Log级别复杂度的算法:

简单点我们可以这么想:

1)先假设第k大数在A中,我们首先从A中第(m/(m + n)) * (k - 1)个元素开始检查其是否是第k个元素,假设其值为A1,然后看B中第(k + 1 - (m/(m + n)) * (k - 1)个元素(B1)和A1是否相等,或者 大于B中第(k + 1 - (m/(m + n)) * (k - 1))个元素,小于B中第(k + 1 - (m/(m + n)) * (k - 1))+ 1个元素。满足及可以知道A1即为所求。如果两个条件都不满足,请看2.

2)如果两个条件都不满足,那么需要判断第k个元素是处于 A1的左边还是右边,这个就是典型的分治思想。具体的来说:

             if A1 > B1  那么k可以排除肯定不在A[0, (m/(m + n)) * (k - 1)]以及B[(k + 1 - (m/(m + n)) * (k - 1))+ 1, n]中

             if A1< B1  那么k可以排除肯定不在A[ (m/(m + n)) * (k - 1), m]以及B[0, (k + 1 - (m/(m + n)) * (k - 1))]中.

             注意下临界条件(corner condition may not stastify, but the method is right)

第K个元素有可能在B中,同理可以假设在B中,然后再搜索一遍就可以查到。复杂度 log(m)+ log(n)

当然也可以两个数组一起找,总体代码如下:

复制代码
 1     int kthsmallest(int *a,int m,int *b,int n,int k) {
 2         if (m == 0) {
 3             return b[k - 1];
 4         }
 5         if (n == 0) {
 6             return a[k - 1];
 7         }
 8         if (k == 1) {
 9             return (a[0] < b[0])?a[0]:b[0];
10         }
11         if (k == m + n) {
12             return (a[m - 1] > b[n - 1])?a[m - 1]:b[n - 1];
13         }
14         int i = ((double) m) / (m + n) * (k - 1);
15         int j = k - 1 - i;
16         if (j >= n) {
17             j = n - 1;
18             i = k - n;
19         }
20         if (((i == 0) || (a[i - 1] <= b[j])) && (b[j] <= a[i])) {
21             return b[j];
22         }
23         if (((j == 0) || (b[j - 1] <= a[i])) && (a[i] <= b[j])) {
24             return a[i];
25         }
26         if (a[i] <= b[j]) {
27             return kthsmallest(a + i + 1, m - i - 1, b, j, k - i - 1);
28         } else {
29             return kthsmallest(a, i, b + j + 1, n - j - 1, k - j - 1);
30         }
31 
32     }
复制代码
给定两个有序数组,假设数组 `nums1` 的长度为 `m`,数组 `nums2` 的长度为 `n`。为了方便起见,假设 `m ≤ n`。要求解这两个有序数组中位数或第 `k` 小的元素,可以采用以下两种方法。 ## 方法一:归并排序 这种方法的思路很简单,就是将两个有序数组归并成一个有序数组,然后再根据数组长度和 k 的值确定中位数或第 k 小的元素。具体步骤如下: 1. 定义两个指针 `p1` 和 `p2`,分别指向数组 `nums1` 和 `nums2` 的起始位置。 2. 定义一个新数组 `nums3`,用于存放归并后的有序数组。 3. 循环执行以下步骤,直到 `nums3` 有 `k` 个元素: 1. 比较 `nums1[p1]` 和 `nums2[p2]` 的大小,将较小的元素加入 `nums3` 。 2. 将指向较小元素的指针后移一位。 4. 如果 `m + n` 是奇数,则 `nums3[(m+n)/2]` 就是中位数;否则 `nums3[(m+n)/2-1]` 和 `nums3[(m+n)/2]` 的平均值就是中位数。如果要求第 k 小的元素,则返回 `nums3[k-1]`。 时间复杂度为 $O(m+n)$。 ## 方法二:二分查 这种方法的思路比较巧妙,其核心思想是在两个有序数组找到第 k 小的元素,假设这个元素在数组 `nums1` 的位置是 `i`,在数组 `nums2` 的位置是 `j`。那么有以下两种情况: 1. 如果 `nums1[i] < nums2[j]`,则数组 `nums1[0...i]` 的所有元素都是第 k 小的元素的候选元素,因为这些元素都小于 `nums2[j]`,而 `nums2[0...j]` 的所有元素都不可能是第 k 小的元素,因为这些元素都小于 `nums1[i]`。 2. 如果 `nums1[i] >= nums2[j]`,则数组 `nums2[0...j]` 的所有元素都是第 k 小的元素的候选元素,因为这些元素都小于 `nums1[i]`,而 `nums1[0...i]` 的所有元素都不可能是第 k 小的元素,因为这些元素都小于 `nums2[j]`。 具体步骤如下: 1. 定义两个指针 `p1` 和 `p2`,分别指向数组 `nums1` 和 `nums2` 的起始位置。 2. 循环执行以下步骤,直到找到第 k 小的元素: 1. 如果 `p1 >= m`,说明数组 `nums1` 已经没有元素可以参与比较,直接返回 `nums2[p2+k-1]`。 2. 如果 `p2 >= n`,说明数组 `nums2` 已经没有元素可以参与比较,直接返回 `nums1[p1+k-1]`。 3. 如果 `k == 1`,直接返回 `min(nums1[p1], nums2[p2])`。 4. 比较 `nums1[p1+k/2-1]` 和 `nums2[p2+k/2-1]` 的大小,如果前者小于等于后者,则说明 `nums1[0...k/2-1]` 的所有元素都小于等于第 k 小的元素,可以把这些元素全部排除掉,更新 `k` 的值为原来的一半,并将指向 `nums1` 的指针后移 `k/2` 个位置;否则说明 `nums2[0...k/2-1]` 的所有元素都小于等于第 k 小的元素,可以把这些元素全部排除掉,更新 `k` 的值为原来的一半,并将指向 `nums2` 的指针后移 `k/2` 个位置。 3. 如果要求中位数,则返回第 `(m+n)/2` 小的元素和第 `(m+n)/2+1` 小的元素的平均值;如果要求第 k 小的元素,则返回第 k 小的元素。 时间复杂度为 $O(\log(m+n))$。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值