几种查找数组的前K个最小值的算法

最新推荐文章于 2022-06-12 22:06:39 发布
最新推荐文章于 2022-06-12 22:06:39 发布
阅读量544 收藏
点赞数
分类专栏： 算法 文章标签： 算法 数据结构 选择排序

此文转载于http://blog.chinaunix.net/uid-20937170-id-3347493.html      保存起来以后方便找


    1、对数组进行排序，然后前K个元素就是需要查找的元素，排序的方法可以采用快速排序，但是我们知道在快速排序中如果已经是有序的数组，采用快速排序的时间复杂度是O(N^2),为了解决这种问题，通常选择随机选择一个数组值pivot作为基准，将数组分为S1 =< pivot和S2 > pivot，这样就能避免快速排序中存在的问题，或者采用随机选择三个元素，然后取中间值作为基准就能避免快速算法的最差时间复杂度，这种方法的前K个数字是有序的。
 
    2、既然是选择前K个对象，那么就没必要对所有的对象进行排序，可以采用快速选择的思想获得前K个对象，比如首先采用快速排序的集合划分方法划分集合：S1，pivot，S2，然后比较K是否小于S1的个数，如何小于，则直接对S1进行快速排序，如果K的个数超过S1,那么对S2进行快速排序，排序完成之后，取数组的前K个元素就是数组的前K个最小值。这种实现方法肯定比第一种的全快速排序要更快速。
 
    3、将数组转换为最小堆的情况，根据最小堆的特性，第一个元素肯定就是数组中的最小值，这时候我们可以将元素保存起来，然后将最后一个元素提升到第一个元素，重新构建最小堆，这样进行K次的最小堆创建，就找到了前K个最小值，这是运用了最小堆的特性，实质上是最小堆的删除实现方法。这种算法的好处是实现了数组的原地排序，并不需要额外的内存空间。
 
    4、接下来的这种思想有点类似桶排序，首先给定一个K个大小的数组b，然后复制数组a中的前K个数到数组b中，将这K个数当成数组a的前K个最小值，对数组b创建最大堆，这时候再次比较数组a中的其他元素，如果其他元素小于数组b的最大值（堆顶），则将堆顶的值进行替换，并重新创建最大堆。这样遍历一次数组就找到了前K个最小元素。这种方法运用了额外的内存空间，特别当选择的K值比较大时，这种方法有待于权衡一下。
    这种方法对于海量数据来说是有较好的作用，对于海量数据不能全部存放在内存中，这时候创建一个较小的数组空间，然后创建最大堆，从硬盘中读取其他的数据，进而实现前K个数据的查找。

下面是代码实现： 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
#include<time.h>

#define LEN 500000
#define K 100

/*堆的性质*/
#define LEFTSON(i) (2*(i)+1)
#define RIGHTSON(i) (2*((i)+1))
#define PARENT(i) (((i)-1)/2)

void swap(int *a, int *b)
{
        assert(a != NULL && b != NULL);

        if(a != b)
        {
                *a = *a ^ *b;
                *b = *a ^ *b;
                *a = *a ^ *b;
        }
}

int partition(int *a, int left, int right)
{
        int pivot = a[right];
        int i = left;
        int j = left - 1;

        assert(a != NULL);

        for(i = left; i < right; ++ i)
        {
                if(a[i] < pivot)
                {
                        ++ j;
                        swap(&a[i],&a[j]);
                }
        }
        swap(&a[j + 1],&a[right]);
        return (j + 1);
}

void quicksort(int *a, int left, int right)
{
        int i = 0;

        assert(a != NULL);

        if(left < right)
        {
                i = partition(a,left,right);
                quicksort(a, left, i - 1);
                quicksort(a, i + 1, right);
        }
}

int QuickSort(int *a, int size)
{
        assert(a != NULL);
        quicksort(a,0,size-1);
}

void quickselect(int *a, int left, int right, int k)
{
        int i = 0;

        assert(a != NULL && left <= k
                && left <= right && k <= right);

        if(left < right)
        {
                i = partition(a, left, right);
                if(i + 1 <= k)
                        quickselect(a, i + 1 , right, k);
                else if(i > k)
                        quickselect(a, left, i - 1, k);
        }
}

void QuickSelect(int *a, int size, int k)
{
        assert(a != NULL);
        quickselect(a, 0, size - 1, k);
}

/*最大堆*/
void max_heapify(int *a, int left, int right)
{
        int tmp = 0;
        int child = left;
        int parent = left;

        assert(a != NULL);

        for(tmp = a[parent]; LEFTSON(parent) <= right;parent = child)
        {
                child = LEFTSON(parent);

                if(child != right && a[child] < a[child + 1])
                        child ++;

                if(tmp < a[child])
                        a[parent] = a[child];
                else /*满足最大堆的特性，直接退出*/
                        break;
        }
        a[parent] = tmp;
}

/*创建最大堆*/
void build_maxheap(int *a, int size)
{
        int i = 0;
        assert(a != NULL);

        for(i = PARENT(size); i >= 0 ; -- i)
                max_heapify(a,i,size - 1);
}

/*最小堆的实现*/
void min_heapify(int *a, int left, int right)
{
        int child = 0;
        int tmp = 0;
        int parent = left;

        assert(a != NULL);

        for(tmp = a[parent]; LEFTSON(parent) <= right; parent = child)
        {
                child = LEFTSON(parent);

                if(child != parent && a[child] > a[child + 1])
                        child ++;

                if(a[child] < tmp)
                        a[parent] = a[child];
                else /*满足最小堆的特性，直接退出*/
                        break;
        }
        a[parent] = tmp;
}

/*创建最小堆*/
void build_minheap(int *a, int size)
{
        int i = PARENT(size);

        assert(a != NULL);

        for(; i >= 0; -- i)
                min_heapify(a, i, size - 1);
}

/*采用快速排序查找*/
void find_Kmin_num_1(int *a , int size, int k)
{
        int i = 0;

        assert(a != NULL);

        QuickSort(a, size);

#if 0
        for(i = 0; i < k ; ++ i)
                printf("%d\t",a[i]);

        printf("\n");
#endif
}

/*采用快速选择实现*/
void find_Kmin_num_2(int *a, int size, int k)
{
        int i = 0;

        assert(a != NULL);

        QuickSelect(a, size, k);

#if 0
        for(i = 0; i < k ; ++ i)
                printf("%d\t",a[i]);

        printf("\n");
#endif
}

/*采用最大堆实现*/
void find_Kmin_num_3(int *a, int size, int k)
{
        int i = 0;

        int *b = malloc(sizeof(int)*k);

        assert(a != NULL && b != NULL);

        for(i = 0; i < k; ++ i)
                b[i] = a[i];

        build_maxheap(b,k);

        for(; i < size; ++ i)
        {
                if(a[i] < b[0])
                {
                        b[0] = a[i];
// build_maxheap(b , k);
                        max_heapify(b,0,k - 1);
                }
        }
#if 0
        for(i = 0; i < k ; ++ i)
                printf("%d\t",b[i]);

        printf("\n");
#endif
}

/*采用最小堆删除元素的方式实现*/
void find_Kmin_num_4(int *a ,int size, int k)
{
        int i = 0;

        assert(a != NULL);

        build_minheap(a, size - 1);
        for(i = 0; i < k; ++ i)
        {
// printf("%d\t",a[0]);

                /*删除a[0]，释放a[size - 1 - i]*/
                a[0] = a[size -1 - i];
                min_heapify(a, 0, size - 2 - i);
        }
// printf("\n");
}

int main()
{
        int a[LEN];
        int b[LEN];
        int c[LEN];
        int d[LEN];

        int i = 0,j = 0;

        clock_t _start;
        double times = 0;

        srand((int)time(NULL));

        for(i = 0; i < LEN; ++ i)
        {
                a[i] = rand()%(LEN);
                b[i] = a[i];
                c[i] = a[i];
                d[i] = a[i];

// printf("%d\t",a[i]);
        }
// printf("\n");

        _start = clock();
        find_Kmin_num_1(a,LEN,K);
        times = (double)(clock() - _start)/CLOCKS_PER_SEC;
        printf("快速排序的查找需要:%f\n",times);

        _start = clock();
        find_Kmin_num_2(b,LEN,K);
        times = (double)(clock() - _start)/CLOCKS_PER_SEC;
        printf("快速选择的查找需要:%f\n",times);

        _start = clock();
        find_Kmin_num_3(c,LEN,K);
        times = (double)(clock() - _start)/CLOCKS_PER_SEC;
        printf("最大堆的查找需要:%f\n",times);

        _start = clock();
        find_Kmin_num_4(d,LEN,K);
        times = (double)(clock() - _start)/CLOCKS_PER_SEC;
        printf("最小堆的查找需要:%f\n",times);

        return 0;
}


算法性能：

快速排序的查找需要:0.130000

快速选择的查找需要:0.020000

最大堆的查找需要:0.000000

最小堆的查找需要:0.010000


快速排序的算法效果最差，而最大堆的效果最好，最小堆的效果其次，但是最大堆运用了额外的内存空间。因此在内存空间限制的情况下，考虑最小堆是比较合适的。但是最大堆的思想确实很精妙的，运用了类似桶排序的性质。


Code_Junior
关注
专栏目录
每日一题1：查找前k个最小值
爱拍球的程序圆
03-18 839
查找前k个最小值最直接的方式是遍历输入数组k遍，每次找出剩下输入中的最小值，每次查找过程中采用交换的策略，这样程序运行结束原数组的前k个数就是按顺序排列的前k个最小数，第二种思路是维护一个具有k个元素的查找树（初始化为输入数组的前k个数），对输入数组的后续每个元素a，将其与查找树的最大数b比较，如果a>=b，则什么也不做，如果a < b，则将b删除，再将a插入到查找树中，如此即可在O（n+klogn
求数组中的最大最小值
weixin_45646463的博客
01-02 6040
求数组中最大最小值的几种方法： 问题分解法：遍历两次数组，反别求出最大值和最小值 取单元素法：两个变量，变量min标记最小值，变量max标记最大值，每次循环取出一个元素来与最大值最小值比较。 取双元素法：两个变量，变量min标记最小值，变量max标记最大值，每次循环取出两个元素，先比较两个元素的大小，小的和最小值比较，大的和最大值作比较。 数组元素位移法：将数组中相邻两个数分在一组，每次比较两个...
数据结构与算法分析（一）——查找前k个最小值
weixin_30545285的博客
11-03 257
好久没有写博客了，这一段时间主要在准备为将来找工作复习，今天我就总结一下关于如何查找数组的前K个最小值实现方法，查找前K个最小值实现方法很多，主要的思想包括如下的几种： 1、对数组进行排序，然后前K个元素就是需要查找的元素，排序的方法可以采用快速排序，但是我们知道在快速排序中如果已经是有序的数组，采用快速排序的时间复杂度是O(N^2),为了解决这种问题，通常选择随机选择一个数组值piv...
利用快排求数组中前K个最小值
belongHWL的博客
08-18 281
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> void Show(int arr[], int k) { int i = 0; for (i = 0; i < k; i++) { printf("%3d", arr[i]); } printf("\n"); ...
查找数组的前K个最小值的算法
sjphiChina的博客
08-01 984
备忘，参考：点击打开链接 1. Simple Solution：A Simple Solution is to sort the given array using a O(nlogn) sorting algorithm like Merge Sort, Heap Sort, etc and return the element at index k-1 in the sorted
从数组中寻找前k小的数据
weixin_30558305的博客
08-09 87
#include<stdio.h> void find_bigger_num(int *arr ,int iLeft ,int iRight ,int iTargetSize ){ if( iLeft>= iRight) return; int iPivot = arr[ iLeft]; int iBegin = iLe...
几种查找数组的前K个最小值的算法.docx
07-10
"查找数组的前K个最小值的算法" 查找数组的前K个最小值是计算机科学中的一种常见问题，它广泛应用...查找数组的前K个最小值问题可以通过各种算法来解决，每种算法都有其优缺点，选择合适的算法取决于具体情况的需求。
几种查找数组的前K个最小值的算法.pdf
07-10
标题提及的“几种查找数组的前K个最小值的算法”是计算机科学中常见的问题，主要涉及算法和数据结构的应用。以下是对这些方法的详细解释： 1. **排序法**： - 最简单的方法是先对整个数组进行排序，然后直接选取前...
数组最大值最小值_数组最大值最小值_最小值_
09-30
要找出数组中的最大值和最小值，有几种常见的方法： 1. **遍历法**：这是最直观的方法，通过遍历数组中的每一个元素，比较当前元素与已知最大值和最小值，更新这两个值。这种方法简单易懂，适用于所有支持迭代的...
分治算法求最大值与最小值，找最小元素
11-17
1. 设计程序利用分治策略求n个数的最大值和最小值。 2. 利用分治策略，在n个不同元素中找出第k个最小元素。
剑指offer：040找出无序数组中前K小的数
山沟沟的博客
11-24 246
# 利用快排思想 class Solution: def function(self, array, K): index = self.partition(array, 0, len(array)-1) while index != K-1: if index &amp;gt; K-1: index = sel...
在一个数组中找到前k个小（大）的数
Nigel_Lee专栏
01-25 833
11.给定一个一维数组，找出其中最小的前K个数，要求算法的时间复杂度为O(nlogK) solution： 借鉴堆排序的算法，通过使用最小堆选出前K个最小的数。 首先创建size=K的最小堆；堆顶为堆中最大的元素。 然后遍历数组元素，往最小堆中插入元素，如果堆的个数已经达到K。那么新插入的元素需要和堆顶元素比较。如果这个元素小于 堆顶元素，将堆顶元素移除，插入新的元素。 最后当遍历结束
07--查找最小值（二分法）
weixin_44533869的博客
04-07 940
查找最小值（可以采用二分法） # -*- coding: utf-8 -*- class Solution: def minNumberInRotateArray(self, rotateArray): """ # O(n)的复杂度 minNum = 0 for i in range(len(rotateArray)): minNum = minNum if minNum < rotateArray[i] and minNum != 0 else rotateArray[i
找数组中前K小或者前K大
choudan8888的博客
08-14 285
思路：我们在这里用到一个快排的思想，快排一次得到位置pos，在这个pos之前的数据全比和比较的数小（或者大），它后面的数全比和比的数大（或者小），如下图，快排第一次用6来和其他数比较，排序一次之后，在6之前的数字一定会比6小，在6之后的数字一定会比6大。 如果你要找第3小则需要在6前面找，就要执行quicksort(arr, left, index, k);反之，找第7小的话，就需要在6后面...
获取数组的前K小个数
周平的专栏
05-04 563
#include<iostream> using namespace std; int partition(int* array, int low, int high) { if (array && low < high) { int flag = array[low]; while (low < high) ...
获取数组中前K小的数字
跑码场
11-19 404
public class GetMinKNums { //向堆中插入元素 public static void insert(int[] arr, int index, int value) { arr[index] = value; while (index != 0) { int parent = (index - 1) ...
【编程算法Ⅲ】查找某数、查找某个位置、局部最小值（二分法）（Python解法）
尹煜的博客
06-12 953
大家如果有疑问都可以评论提出，有不足之处请大家批评指正，希望能多结识这方面的朋友，共同学习、共同进步。
高效查找数组前K小元素：算法解析
"这篇文章主要介绍了查找数组中前K个最小值的几种常见算法，包括排序、快速选择、最小堆和桶排序的变体。作者强调这些算法在解决实际问题时，尤其是在处理大规模数据时的不同优势和适用场景。" 在数组处理中，查找...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值