《编程之美》——寻找最大的K个数
2015-11-22 19:52
218 查看
题目:
N个无序的数(可能数目非常大),选出其中最大的K个数。
分析与解法:
【解法一】
对N个数进行排序,然后选出最大的K个数。可以使用快速排序或堆排序,时间复杂度为O(NlogN)。
因为这里N的数目可能非常大,即N>>K,而前N-K个数可以不进行排序,使用可以部分排序的算法,如选择排序或交换排序,时间复杂度为O(NK)。
【解法二】
当N的数值很大的时候,即N>>K。可以使用快速排序中的partition函数, 将数分为两组。
(1)分为两个组,sa和sb。
(2)若sa组的个数大于K,则继续在sa分组中找取最大的K个数字 。
(3)若sa组中的数字小于K ,其个数为T,则继续在sb中找取 K-T个数字 。
时间复杂度为O(NlogK)。
代码:
【解法三】
该问题的实质是寻找最大的K个数中最小的那个,也就是第K大的数p,可以先找出N个数中最大的和最小的元素的值,然后使用二分法进行搜索找到p,再根据p找到其他大于它的K-1个数。其时间复杂度是O(N)+O(NlogN)+O(N),近似后为O(NlogN)。
代码:
【解法四】
当N的数值很大的时候,即N>>K。从N个数中任取K个数建立一个有K个节点的小顶堆,每次从剩下N-K个数中取出一个数,与堆顶元素进行比较,若小于等于堆顶元素则舍弃,若大于等于堆顶,则将堆顶元素更新为该元素并重新调整堆。维护堆的时间复杂度是O(logK)。所以总的时间复杂度是O(NlogK)。
代码:
【解法五】
N个数都是正整数,且取值范围不大的时候。可以使用空间换时间的方法,使用一个数组记录每个元素出现的次数,数组长度为MAXN,为N个数中的最大元素的值,然后找出最大的K个数。时间复杂度为O(N)+O(MAXN),近似为O(N)。
代码:
扩展问题:
1.如果需要找出N个数中最大的K个不同的浮点数呢?比如,含有10个浮点数的数组(1.5,1.5,2.5,3.5,3.5,5,0,- 1.5,3.5)中最大的3个不同的浮点数是(5,3.5,2.5)。
2.如果是找第k到第m大的数呢?
3.在搜索引擎中,网络上的每个网页都有“权威性”权重,如page rank。如果我们需要寻找权重最大的K个网页,而网页的权重会不断地更新,那么算法要如何变动以达到快速更新(incremental update)并及时返回权重最大的K个网页?
提示:堆排序?当每一个网页权重更新的时候,更新堆。还有更好的方法吗?
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。
5.如第4点所说,对于每个文档d,相对于不同的关键字q1, q2, …, qm,分别有相关性权重f(d, q1),f(d, q2), …, f(d, qm)。如果用户输入关键字qi之后,我们已经获得了最相关的K个文档,而已知关键字qj跟关键字qi相似,文档跟这两个关键字的权重大小比较靠近,那么关键字qi的最相关的K个文档,对寻找qj最相关的K个文档有没有帮助呢?
分析与解法:
1.除了解法五,其他四种方法都可以。还可以利用解法五的思想使用STL中的map存储每个数出现的次数,之后从大到小扫描出K个最大的数,时间复杂度为O(nlogn),空间复杂度为O(n),因为STL中map是由红黑树实现的,每次插入的时间复杂度为O(logn)。
2.维护一个m个节点的小顶堆,然后遍历找出比第m大的元素小的m-k个元素。
3.4.5.解法见参考博文。
文章及代码参考以下博文:
http://www.2cto.com/kf/201504/388795.html
http://blog.csdn.net/rein07/article/details/6742933
N个无序的数(可能数目非常大),选出其中最大的K个数。
分析与解法:
【解法一】
对N个数进行排序,然后选出最大的K个数。可以使用快速排序或堆排序,时间复杂度为O(NlogN)。
因为这里N的数目可能非常大,即N>>K,而前N-K个数可以不进行排序,使用可以部分排序的算法,如选择排序或交换排序,时间复杂度为O(NK)。
【解法二】
当N的数值很大的时候,即N>>K。可以使用快速排序中的partition函数, 将数分为两组。
(1)分为两个组,sa和sb。
(2)若sa组的个数大于K,则继续在sa分组中找取最大的K个数字 。
(3)若sa组中的数字小于K ,其个数为T,则继续在sb中找取 K-T个数字 。
时间复杂度为O(NlogK)。
代码:
#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 = {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大的数p,可以先找出N个数中最大的和最小的元素的值,然后使用二分法进行搜索找到p,再根据p找到其他大于它的K-1个数。其时间复杂度是O(N)+O(NlogN)+O(N),近似后为O(NlogN)。
代码:
#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 ; } return min ; } int main() { int a = {54, 2 ,5 ,11 ,554 ,65 ,33 ,2}; int x = getK(a , 554 , 2); cout << x << " "; for(int i = 0; i < N; i++) { if(x < a[i]) cout << a[i] << " "; } return 0 ; }
【解法四】
当N的数值很大的时候,即N>>K。从N个数中任取K个数建立一个有K个节点的小顶堆,每次从剩下N-K个数中取出一个数,与堆顶元素进行比较,若小于等于堆顶元素则舍弃,若大于等于堆顶,则将堆顶元素更新为该元素并重新调整堆。维护堆的时间复杂度是O(logK)。所以总的时间复杂度是O(NlogK)。
代码:
#include <iostream> using namespace std; void buildMinHeap(int *pArray, int K); void adjustHeap(int *pArray, int rootIndex, int heapSize); int main() { int a[] = {9, 8, 7, 6, 5, 4, 3, 11, 12, 13, 1, 28}; int K = 5 ; //建一个K个元素大小的最小堆 buildMinHeap(a, K); //从第K个元素开始扫描,看有没有比根节点更大的节点,若有则替换,并更新堆;若没有比根节点大则扫描下一个元素,直到数组结束 for (int i = K; i < sizeof(a) / sizeof(int); i++) { if (a[i] > a[0]) { swap(a[i], a[0]); adjustHeap(a, 0, K); } } //打印出前K大的数,没有排序。 for (int i = 0; i < K; i++) { cout << a[i] << " "; } system("pause"); } //建一个K个元素大小的最小堆 void buildMinHeap(int *pArray, int K) { for (int i = (K - 2) / 2; i >= 0; i--) { adjustHeap (pArray, i, K); } } void adjustHeap (int *pArray, int rootIndex, int heapSize) { int minIndex = rootIndex; //左孩子节点 int leftIndex = 2 * rootIndex + 1; //右孩子节点 int rightIndex = 2 * (rootIndex + 1); //如果左孩子比根节点和右孩子节点小的话,则左孩子和根节点进行交换 if ((leftIndex < heapSize) && (rightIndex < heapSize) && (pArray[leftIndex] < pArray[rootIndex])) { minIndex = leftIndex; } if ((leftIndex < heapSize) && (rightIndex >= heapSize) && (pArray[leftIndex] < pArray[rootIndex])) { minIndex = leftIndex; } if ((rightIndex < heapSize) && (pArray[rightIndex] < pArray[leftIndex]) && (pArray[rightIndex] < pArray[rootIndex])) { minIndex = rightIndex; } if (minIndex != rootIndex) { //如果左孩子或者右孩子比根节点小的话,那么就交换,并且重新调整以 //minIndex为根节点的子树 swap(pArray[rootIndex], pArray[minIndex]); adjustHeap(pArray, minIndex, heapSize); } }
【解法五】
N个数都是正整数,且取值范围不大的时候。可以使用空间换时间的方法,使用一个数组记录每个元素出现的次数,数组长度为MAXN,为N个数中的最大元素的值,然后找出最大的K个数。时间复杂度为O(N)+O(MAXN),近似为O(N)。
代码:
#include <iostream> using namespace std; int findMaxN(int *pArray, int len); int main() { int a[] = {9, 8, 7, 6, 5, 4, 3, 11, 12, 13, 1, 28}; int K = 5; int MAXN = findMaxN(a, sizeof(a) / sizeof(int)); //申请一个count数组,记录每一个数出现的次数 int *count = new int[MAXN + 1](); for (int i = 0; i < sizeof(a) / sizeof(int); i++) { count[a[i]]++; } int index = MAXN; int sumCount = 0; for (;index >= 0; index--) { sumCount += count[index]; if (sumCount == K) { break; } } //打印出最大的K个数 for (int i = MAXN; i >= index; i--) { if (0 != count[i]) { cout << i << " "; } } system("pause"); } //找出一个数组中最大的值 int findMaxN(int *pArray, int len) { int MAXN = pArray[0]; for (int i = 1; i < len; i++) { if (pArray[i] > MAXN) { MAXN = pArray[i]; } } return MAXN; }
扩展问题:
1.如果需要找出N个数中最大的K个不同的浮点数呢?比如,含有10个浮点数的数组(1.5,1.5,2.5,3.5,3.5,5,0,- 1.5,3.5)中最大的3个不同的浮点数是(5,3.5,2.5)。
2.如果是找第k到第m大的数呢?
3.在搜索引擎中,网络上的每个网页都有“权威性”权重,如page rank。如果我们需要寻找权重最大的K个网页,而网页的权重会不断地更新,那么算法要如何变动以达到快速更新(incremental update)并及时返回权重最大的K个网页?
提示:堆排序?当每一个网页权重更新的时候,更新堆。还有更好的方法吗?
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。
5.如第4点所说,对于每个文档d,相对于不同的关键字q1, q2, …, qm,分别有相关性权重f(d, q1),f(d, q2), …, f(d, qm)。如果用户输入关键字qi之后,我们已经获得了最相关的K个文档,而已知关键字qj跟关键字qi相似,文档跟这两个关键字的权重大小比较靠近,那么关键字qi的最相关的K个文档,对寻找qj最相关的K个文档有没有帮助呢?
分析与解法:
1.除了解法五,其他四种方法都可以。还可以利用解法五的思想使用STL中的map存储每个数出现的次数,之后从大到小扫描出K个最大的数,时间复杂度为O(nlogn),空间复杂度为O(n),因为STL中map是由红黑树实现的,每次插入的时间复杂度为O(logn)。
2.维护一个m个节点的小顶堆,然后遍历找出比第m大的元素小的m-k个元素。
3.4.5.解法见参考博文。
文章及代码参考以下博文:
http://www.2cto.com/kf/201504/388795.html
http://blog.csdn.net/rein07/article/details/6742933
相关文章推荐
- QSerialPort适应多线程应用的改进
- python模拟登陆篇——requests & urllib2方式 &有图片验证码情况
- 关于使用Spring声明式事务时,在类的内部方法互相调用时,Spring无法拦截内部方法调用,导致事务不起作用的问题研究
- 自学QT之QML实现响应鼠标和键盘事件
- JAVA解析XML文件(四)---DOM4J方式解析
- C++与C#在变量定义上的区别
- 可变参数列表<stdarg.h>
- JAVA解析XML文件(三)---JDOM方式解析
- Java有没有goto?
- 关于Eclipse(64位)下aptana插件安装报错问题解决
- ubuntu14.04 JDK 安装
- C语言之文件操作
- C语言关键字的使用注意事项
- Spring MVC 入参支持数组
- java数据封装
- 使用Spring Roo构建项目
- python 数据库查询为字典是取对应的值
- JAVA解析XML文件(二)---SAX方式解析
- 代码整洁之道(一)--------有意义的命名
- python3 BIF里的并发与并行处理昝(IPC ITC)=>LTS