编程之美--寻找最大的K个数
来源:互联网 发布:西门子840d循环编程 编辑:程序博客网 时间:2024/05/20 15:59
方法一: 使用partition函数,将数组分为两组。partition函数是快速排序中用来把数组分成两部分的函数。
(1)分为两个组,sa和sb。
(2)若sa组的个数大于K,则继续在sa分组中找取最大的K个数字 。
(3)若sa组中的数字小于K ,其个数为T,则继续在sb中找取 K-T个数字 。
具体代码实现:
- <SPAN style="FONT-SIZE: 16px">#include <iostream>
- using namespace std ;
- const int N = 8 ;
- const int K = 4 ;
- int partition(int a[] ,int low , int high)
- {
- int i = low - 1 ;
- int j = low;
- while(j < high)
- {
- if(a[j] >= a[high])
- {
- swap( a[i+1] , a[j]) ;
- i++ ;
- }
- j++ ;
- }
- //最后处理a[high]
- swap(a[i+1] , a[high]) ;
- return i + 1;
- }
- int findk(int a[] , int low , int high , int k)
- {
- if(low < high)
- {
- int q = partition(a , low , high) ;
- int len = q - low + 1 ; //表示第几个位置
- if(len == k)
- return q ; //返回第k个位置
- else if(len < k)
- return findk(a , q + 1 , high , k - len) ;
- else
- return findk(a , low , q - 1, k ) ;
- }
- }
- int main()
- {
- int a[N] = {5 ,2 ,66 ,23, 11 ,1 ,4 ,55} ;
- findk(a , 0 , N - 1 , K) ;
- for(int i = 0 ; i < K ; i++)
- cout<<a[i]<<endl ;
- system("pause") ;
- return 0 ;
- } </SPAN>
#include <iostream> using namespace std ; const int N = 8 ; const int K = 4 ; int partition(int a[] ,int low , int high) { int i = low - 1 ; int j = low; while(j < high) { if(a[j] >= a[high]) { swap( a[i+1] , a[j]) ; i++ ; } j++ ; } //最后处理a[high] swap(a[i+1] , a[high]) ; return i + 1; } int findk(int a[] , int low , int high , int k) { if(low < high) { int q = partition(a , low , high) ; int len = q - low + 1 ; //表示第几个位置 if(len == k) return q ; //返回第k个位置 else if(len < k) return findk(a , q + 1 , high , k - len) ; else return findk(a , low , q - 1, k ) ; } } int main() { int a[N] = {5 ,2 ,66 ,23, 11 ,1 ,4 ,55} ; findk(a , 0 , N - 1 , K) ; for(int i = 0 ; i < K ; i++) cout<<a[i]<<endl ; system("pause") ; return 0 ; }
方法二 :
此种方法为常用方法,建立一个大小为K的堆。每次遍历数组时,需要判断是否需要加入堆中。
堆中存储着的是最大的k个数字,但是若是需要插入堆中,则需要对堆进行调整时间为o(log k)。
全部的时间复杂度为o(n * log k)。
这种方法当数据量比较大的时候,比较方便。因为对所有的数据只会遍历一次,第一种方法则会多次遍历
数组。 如果所查找的k的数量比较大。可以考虑先求出k` ,然后再求出看k`+1 到 2 * k`之间的数字,然后
一次求取。
方法三:
利用二分的方法求取TOP k问题。
首先查找 max 和 min,然后计算出 mid = (max + min) / 2
该算法的实质是寻找最大的K个数中最小的一个。
代码如下:
- <SPAN style="FONT-SIZE: 16px">#include <iostream>
- using namespace std ;
- const int N = 8 ;
- const int K = 4 ;
- /*
- 利用二分的方法求取TOP k问题。
- 首先查找 max 和 min,然后计算出 mid = (max + min) / 2
- 该算法的实质是寻找最大的K个数中最小的一个。
- */
- int find(int * a , int x) //查询出大于或者等于x的元素个数
- {
- int sum = 0 ;
- for(int i = 0 ; i < N ; i++ )
- {
- if(a[i] >= x)
- sum++ ;
- }
- return sum ;
- }
- int getK(int * a , int max , int min) //最终max min之间只会存在一个或者多个相同的数字
- {
- while(max - min > 1) //max - min的值应该保证比两个最小的元素之差要小
- {
- int mid = (max + min) / 2 ;
- int num = find(a , mid) ; //返回比mid大的数字个数
- if(num >= K) //最大的k个数目都要比min值大
- min = mid ;
- else
- max = mid ;
- }
- cout<<"end"<<endl;
- return min ;
- }
- int main()
- {
- int a[N] = {54, 2 ,5 ,11 ,554 ,65 ,33 ,2} ;
- int x = getK(a , 554 , 2) ;
- cout<<x<<endl ;
- getchar() ;
- return 0 ;
- }</SPAN>
#include <iostream> using namespace std ; const int N = 8 ; const int K = 4 ; /* 利用二分的方法求取TOP k问题。 首先查找 max 和 min,然后计算出 mid = (max + min) / 2 该算法的实质是寻找最大的K个数中最小的一个。 */ int find(int * a , int x) //查询出大于或者等于x的元素个数 { int sum = 0 ; for(int i = 0 ; i < N ; i++ ) { if(a[i] >= x) sum++ ; } return sum ; } int getK(int * a , int max , int min) //最终max min之间只会存在一个或者多个相同的数字 { while(max - min > 1) //max - min的值应该保证比两个最小的元素之差要小 { int mid = (max + min) / 2 ; int num = find(a , mid) ; //返回比mid大的数字个数 if(num >= K) //最大的k个数目都要比min值大 min = mid ; else max = mid ; } cout<<"end"<<endl; return min ; } int main() { int a[N] = {54, 2 ,5 ,11 ,554 ,65 ,33 ,2} ; int x = getK(a , 554 , 2) ; cout<<x<<endl ; getchar() ; return 0 ; }
- for(sumCount = 0, v = MAXN -1; v >=0; v--)
- {
- cumCount += count[v];
- if(sumCount >= k)
- break;
- }
- return v;
for(sumCount = 0, v = MAXN -1; v >=0; v--){ cumCount += count[v]; if(sumCount >= k) break;}return v;
个人觉得除了最后一种方法不行,其他的都可以。因为最后一种需要是正数。
提示:堆排序?当每一个网页权重更新的时候,更新堆。还有更好的方法吗?
4. 在实际应用中,还有一个“精确度”的问题。我们可能并不需要返回严格意义上的最大的K个元素,在边界位置允许出现一些误差。当用户输入一个query的时候,对于每一个文档d来说,它跟这个query之间都有一个相关性衡量权重f (query, d)。搜索引擎需要返回给用户的就是相关性权重最大的K个网页。如果每页10个网页,用户不会关心第1000页开外搜索结果的“精确度”,稍有误差是可以接受的。比如我们可以返回相关性第10 001大的网页,而不是第9999大的。在这种情况下,算法该如何改进才能更快更有效率呢?网页的数目可能大到一台机器无法容纳得下,这时怎么办呢?
提示:归并排序?如果每台机器都返回最相关的K个文档,那么所有机器上最相关K个文档的并集肯定包含全集中最相关的K个文档。由于边界情况并不需要非常精确,如果每台机器返回最好的K’个文档,那么K’应该如何取值,以达到我们返回最相关的90%*K个文档是完全精确的,或者最终返回的最相关的K个文档精确度超过90%(最相关的K个文档中90%以上在全集中相关性的确排在前K),或者最终返回的最相关的K个文档最差的相关性排序没有超出110%*K。
网上答案:答:正如提示中所说,可以让每台机器返回最相关的K'个文档,然后利用归并排序的思想,得到所有文档中最相关的K个。 最好的情况是这K个文档在所有机器中平均分布,这时每台机器只要K' = K / n(n为所有机器总数);最坏情况,所有最相关的K个文档只出现在其中的某一台机器上,这时K'需近似等于K了。我觉得比较好的做法可以在每台机器上维护一个堆,然后对堆顶元素实行归并排序。5. 如第4点所说,对于每个文档d,相对于不同的关键字q1, q2, …, qm,分别有相关性权重f(d, q1),f(d, q2), …, f(d, qm)。如果用户输入关键字qi之后,我们已经获得了最相关的K个文档,而已知关键字qj跟关键字qi相似,文档跟这两个关键字的权重大小比较靠近,那么关键字qi的最相关的K个文档,对寻找qj最相关的K个文档有没有帮助呢?
解答:肯定是有帮助的。 qi最相关的K个文档可能就是qj的最相关的K个文档,可以先假设这K个就是,然后根据问题四的解法获得K',分别和这K个比较,可以用堆进行比较,从而获得qj最相关的K个文档。由于最开始的K个文档极有可能是最终的K个文档,所以K'和K比较的次数可能并不多。
参考:
本文出自:http://blog.csdn.net/rein07/article/details/6742933
- 编程之美系列之寻找最大的K个数
- 编程之美之2.5 寻找最大的K个数
- 编程之美之寻找最大的k个数
- 编程之美系列之寻找最大的K个数
- 《编程之美》 : 寻找最大的K个数
- 编程之美2.5 寻找最大的K个数
- 编程之美--寻找最大的K个数
- 编程之美 读书笔记(寻找最大的k个数)
- 编程之美 2.5 寻找最大的K个数(1)
- 编程之美2.5寻找最大的K个数
- 【编程之美】读书笔记:寻找最大的K个数
- 【编程之美】读书笔记:寻找最大的K个数[转帖]
- 编程之美——寻找最大的K个数
- 编程之美2.5 寻找最大的K个数
- 编程之美 2.5 寻找最大的K个数
- 编程之美-2.5寻找最大的K个数
- 编程之美-2.5寻找最大的K个数
- 编程之美—寻找最大的k个数
- UNICODE,GBK,UTF-8区别
- Android Studio 快捷键,希望能祝你一臂之力。
- 图像傅里叶变换
- Maven的安装和配置
- 贝叶斯算法应用于反垃圾邮件
- 编程之美--寻找最大的K个数
- A10/A20 Bootloader加载过程分析
- MapReduce中的Shuffle和Sort分析
- button+textbox另类FileUpload控件给变量赋值
- 使用VISUAL C++开发SOAP客户端应用
- poj1020
- java发送短信
- 数组中出现次数超过一半的数字
- 润乾——新增任务基本属性设置