求第k大数

求第 k k k大数

原文链接

问题

在一组数中,求其第 k k k大数

分析

方法一 排序

可以使用排序算法对原数组进行排序,然后取出其下标为 k k k的数即为第 k k k大数。

时间复杂度

其时间复杂度与所使用的排序算法有关,如归并排序或者快速排序其复杂度为 O ( n l o g n ) O(nlogn) O(nlogn)

方法二 堆

根据原数组建小根堆,依次弹出 k k k次堆顶,其第 k k k次弹出的数即为第 k k k大数。

时间复杂度

其时间复杂度是 O ( k l o g n ) O(klogn) O(klogn)(弹出堆顶的复杂度是 O ( l o g n ) O(logn) O(logn), 共需弹出 k k k次)。该方法明显优于直接使用排序。

方法三 依据快速排序的思想

在快速排序算法中,一个重要的操作是partition操作, partition选取一个枢轴点,将其放入合适的位置,使其左边均小于等于它,右边均大于它。

≤ v \le v v v v v > v >v >v
L L L R R R

执行完partition操作后,设左边的长度为 L L L, 枢轴点的位置为 p p p(将枢轴元素视为属于左部即 p = = L p==L p==L)

  • L = = k L==k L==k,则枢轴点 v v v即为第 k k k大数
  • k < L k<L k<L, 则在左部求其第 k k k大数
  • k > L k > L k>L, 则在右部求其第 k − L k-L kL大数
时间复杂度

若使用随机化快排算法,则每次partition的划分期望是等分,而且每次只对一半的数据进行递归求解, 因此其时间复杂度为
O ( ∑ n + n 4 + n 8 + ⋯ + 1 ) = O ( 2 n ) = O ( n ) O\left(\sum n+\frac n{4}+\frac n{8}+\cdots + 1 \right)=O(2n)=O(n) O(n+4n+8n++1)=O(2n)=O(n)
可见该算法可在 O ( n ) O(n) O(n)的时间内找到任意第 k k k

编码实现
#include <iostream>
#include <ctime>
using namespace std;

int partition(int data[], int l, int r) {
    // 初始化种子
    srand((unsigned)time(nullptr));
    // 随机选取枢轴元素
    swap(data[l], data[rand() % (r - l + 1) + l]);
    int v = data[l];
    // [l+1, i] <= v, [j, r) >= v
    int i = l + 1, j = r;
    while (true) {
        // 依次找到两边不满足的元素,交换
        while (i <= r && data[i] < v) i++;
        while (j >= l + 1 && data[j] > v) j--;
        if (i > j) break;
        swap(data[i], data[j]);
        i++;
        j--;
    }
    std::swap(data[l], data[j]);
    return j;
}
int fastSearchKNum(int data[], int l, int r, int k) {
    int p = partition(data, l, r);
    // 包含枢轴点的左部长度
    int L = p - l + 1;
    if (L == k) { // 情况1 枢轴元素即为第k大元素
        return data[p];
    } else if (k < L) { // 情况2 第k大元素在左部
        return fastSearchKNum(data, l, p - 1, k);
    } else { // 情况3 第k大元素在右部
        return fastSearchKNum(data, p + 1, r, k - L);
    }
}

int main() {
    int data[] = {5, 4, 3, 2, 1, 6, 8, 7, 10, 9};
    int k = 5;
    int kNum = fastSearchKNum(data, 0, 9, k);
    std::cout << "The " << k << "'th number is " << kNum  << std::endl;
    return 0;
}

输出

The 5'th largest number is 5
  • 4
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
(1) 对于非递增有序序列,我们可以选择使用动态数组来存储,具体的类型定义如下: ```c typedef struct { int *data; // 指向动态数组的指针 int length; // 当前动态数组的长度 } SeqList; ``` (2) 第K大数的算法步骤: - 初始化左右边界,左边界为两个序列的起始位置,右边界为两个序列的结束位置。 - 判断左右边界是否重合,如果重合,则直接返回当前位置的元素。 - 计算左右边界的中间位置,取出该位置的元素。 - 统计两个序列中小于等于该元素的元素个数。如果个数大于等于k,说明第k大的元素在左半边,更新右边界为中间位置;否则第k大的元素在右半边,更新左边界为中间位置+1。 - 重复步骤2-4,直到左右边界重合。 (3) 采用上述动态数组作为存储结构,函数的定义如下: ```c int GetMaxK(SeqList A, SeqList B, int k); ``` 其中,A和B分别为两个非递增有序序列,k为要查找的第k大的数的位置。 函数实现如下: ```c int GetMaxK(SeqList A, SeqList B, int k) { int left_a = 0, right_a = A.length - 1; int left_b = 0, right_b = B.length - 1; while (left_a <= right_a && left_b <= right_b) { int mid_a = (left_a + right_a) / 2; int mid_b = (left_b + right_b) / 2; int mid = 0; if (A.data[mid_a] >= B.data[mid_b]) { mid = A.data[mid_a]; if (mid_a - left_a + mid_b - left_b + 1 >= k) { right_a = mid_a; right_b = mid_b - 1; } else { k -= (mid_a - left_a + 1); left_a = mid_a + 1; } } else { mid = B.data[mid_b]; if (mid_a - left_a + mid_b - left_b + 1 >= k) { right_a = mid_a - 1; right_b = mid_b; } else { k -= (mid_b - left_b + 1); left_b = mid_b + 1; } } } if (left_a > right_a) { return B.data[left_b + k - 1]; } else { return A.data[left_a + k - 1]; } } ``` 该函数的时间复杂度为O(log(m+n)),空间复杂度为O(1)。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值