-
本版专家分：0结帖率 88.89% -
现在有一个1亿个数的整型数组，要从中找出最大的1000个数。并且要求效率尽可能地高，占用的额外空间尽可能的少，不能使用任何库函数。
-
本版专家分：1035 -
弄一个队列，长度为1000
然后遍历你的1000个数
链表不满的时候做从大到小的排序添加数
队列满了之后，每次都对比队尾如果不大于队尾就下一个
大于的话用2分查找法确定位置，然后移除队尾~
遍历完你就得到了1000个最大的数了，
不过你题目不是很清楚，例如1000个数需不要重复的之类，不过这种方法基本上上是可以解决问题~
只是效率一般，额外空间也就1001个数
-
本版专家分：7621
-
- 蓝花 2005年12月 C/C++大版内专家分月排行榜第三
-
-
你可以在 《stl源码剖析》 找 partial_sort_copy 函数相关的算法介绍。。
-
本版专家分：419 -
使用堆排序或者是改进的冒泡排序
void BubbleSort(int r[], int n)
{
int exchange=n; //第一趟起泡排序的范围是r[1]到r[n]
while (exchange) //仅当上一趟排序有记录交换才进行本趟排序
{
if（n-bound>1000)return;//只筛选1000个，放在数组的后1000个中了
bound=exchange;
exchange=0；
for (j=1; j<bound; j++) //一趟起泡排序
if (r[j]>r[j+1])
{
swap(r[j],r[j+1]);
exchange=j； //记录每一次发生记录交换的位置
}
}
}
时间效率为远小于O（n^2） 空间复杂度O（1）
-
本版专家分：5748 -
有序表的优先队列。
-
本版专家分：172 -
这个方法不错
-
本版专家分：345
-
我们只要定义一个的链表，将1亿个数用插入排序法插入，当链表的里元素的个数大于1000时，每插一个数就丢掉一个最小值（head节点），不就行了吗。
-
本版专家分：419
-
不错的方法时间复杂度O(n) 空间复杂度O（n）
-
本版专家分：30
-
建议看看<编程之美>其中有详细讨论；
-
本版专家分：64969
-
-
红花
2011年8月 C/C++大版内专家分月排行榜第一
2010年12月 C/C++大版内专家分月排行榜第一
-
-
黄花
2019年4月 扩充话题大版内专家分月排行榜第二
2019年3月 扩充话题大版内专家分月排行榜第二
2011年9月 C/C++大版内专家分月排行榜第二
2011年4月 C/C++大版内专家分月排行榜第二
2010年11月 C/C++大版内专家分月排行榜第二
-
- 蓝花 2011年6月 C/C++大版内专家分月排行榜第三
-
-
这个方法时间复杂度啥时候成O(n)了？？
-
本版专家分：7
-
个人认为桶排序（我们这里是这样说的，原理大概是位数越多越大，位数相同时第一个数越大这个数越大）可以
只要不是变态数据（比如9*（10^100）和1相比）、、
-
本版专家分：0
-
主要是这个1亿，数据量太大了，用平常的排序方法，效率和空间的利用率，肯定不符合要求。。。不知道有没有相应的例程
-
本版专家分：1468
-
首先使用选择算法选出第1000大的元素。复杂度为O(lg n)。
对1亿来说还是很小的。然后以该元素为分割进行partition。把比该元素大的放到前面，其余不理。复杂度为O(n).
-
本版专家分：1468
-
哦，选择第1000个数的复杂度也是n。整体复杂度是O(n)。只需要O(1)的额外存储空间即可。
-
本版专家分：0
-
对一千个元素的链表执行插入操作 时间复杂度为O（1）,遍历n个元素的时间复杂度为O（n），结果O（1）×O（n）为O（n）. 是这样么？
-
本版专家分：1358
-
可以用 STL 里的 Set 改变一下他的默认排序准则，设置为逆序排序准则，这样子替换最后一个就可以
-
本版专家分：11081 -
昨天 回来这个贴子，恢复的时候断线了.
一亿分成 100 x 100W
然后 100次 100W中找1000个最大数
可以找到10W个最大数
然后10W个中找 1000
懂的人 分析下 算法效率
-
本版专家分：0
-
分割的思想
-
本版专家分：0
-
可以问具体在第几章吗？
-
本版专家分：469
-
看看堆就大致明白了。
-
本版专家分：19
-
well done!
-
本版专家分：19
-
这个想法也很好。
-
本版专家分：370
-
啊。。学习
-
本版专家分：0
-
类似此种问题，是快速排序的变种算法。
-
版主本版专家分：67244
-
-
红花
2013年8月 Linux/Unix社区大版内专家分月排行榜第一
2012年11月 Linux/Unix社区大版内专家分月排行榜第一
2012年10月 Linux/Unix社区大版内专家分月排行榜第一
2012年9月 Linux/Unix社区大版内专家分月排行榜第一
2012年7月 Linux/Unix社区大版内专家分月排行榜第一
2012年6月 Linux/Unix社区大版内专家分月排行榜第一
2012年5月 Linux/Unix社区大版内专家分月排行榜第一
2011年11月 Linux/Unix社区大版内专家分月排行榜第一
-
-
黄花
2013年6月 Linux/Unix社区大版内专家分月排行榜第二
2013年5月 Linux/Unix社区大版内专家分月排行榜第二
2013年3月 Linux/Unix社区大版内专家分月排行榜第二
2013年1月 Linux/Unix社区大版内专家分月排行榜第二
2012年12月 Linux/Unix社区大版内专家分月排行榜第二
2012年8月 Linux/Unix社区大版内专家分月排行榜第二
2011年12月 Linux/Unix社区大版内专家分月排行榜第二
2011年10月 C/C++大版内专家分月排行榜第二
2011年10月 Linux/Unix社区大版内专家分月排行榜第二
-
-
蓝花
2012年6月 C/C++大版内专家分月排行榜第三
2012年6月 PHP大版内专家分月排行榜第三
2012年5月 C/C++大版内专家分月排行榜第三
2012年3月 Linux/Unix社区大版内专家分月排行榜第三
2012年2月 Linux/Unix社区大版内专家分月排行榜第三
2011年11月 C/C++大版内专家分月排行榜第三
-
-
随便写个堆.
-
本版专家分：18035
-
小顶堆 时间复杂度 N*logK
-
本版专家分：40
-
大样本实验，且属于均匀分布。
如，1万个数字属于[1,100]，那么有1万/100 = 100个最大数字100。
所以假设整形数字属于[0,42 9496 7295（2^32-1）]，即无符号32位,那么有
42 9496 7295 / 100 0000 ≈ 4294
个以 1百万 为基数的大数字，且4294 > 1000
所以遍历1亿数字，大于 1百万 的放入集合A
此时集合A的数字均大于 1百万，而且只有4294个，用什么排序都很快了，比如快速排序
----------------------------------------------------------------------------------
基数排序的话这道题应该还行吧？
用比较法的话会受到数字个数的限制啊。。。
-
本版专家分：1911
-
里面有两种方法：
1.前1000个建立一个最小堆，比较之后的数，如果大于堆的头上的数（1000中最小的），将这个数替换成新比较的数，并调整结构使之仍然是一个最小堆，这样，遍历完后，堆中的1000个数就是所需的最大的1000个
2.用（部分）快速排序（从大到小排），因为快整排序是分块有序的，每次排会有(a,...,b,c,d,...,e)其中a..b是无序的，但都大于等于c的，d..e是无序的，但都小于等于c的, 如果a..b的个数等于1000，则a..b就是所要的，如果a..b的个数大于1000， 此时只要继续a..b做快速排序(相同动作)，找出前1000个，如果a..b及c的个数不足1000，则再取两个d..e最大的前n个数就可以了（递归 相同处理)
-
本版专家分：0
-
谢谢哈，学习了
-
本版专家分：40 -
你认识是多少呢
- 100亿个数中找出最大的前K个数（海量数据topK问题）
- 分析：海量数据topK问题，在我们日常生活中应用非常广泛，比如微信的计步软件，它就是topK问题，统计出前K名，然后进行排序。那如何解决这个问题呢？我们用堆可以很好的解决这个问题。我们先用前K<em>个数</em>建立一个大堆/小堆（找<em>最大</em>前K<em>个数</em>用小堆，找最小前K<em>个数</em>用大堆，因为：如果找<em>最大</em>前K<em>个数</em>，我们建立一个大堆的话，我们需要用第N-K-1<em>个数</em>与堆顶元素比较，如果它比堆顶元素小我们就要舍弃它，但如果它比堆顶元...
- 在一亿个数中查找最大的k个数（k << 1,000,000,000）
- 在一亿个整数中查找<em>最大</em>（小）的k<em>个数</em>（k 之前跟一同事说起互联网公司的面试题，他说一般思路是先排序，然后再处理数据肯定没错。是不是这样的呢？对于这个问题，我们想想如下的几个方法： 1.使用大多数情况下最快的排序方法—快速排序来解决可以吗？思路是将一亿个整数放到一<em>个数</em>组中，然后使用快速排序方法把<em>最大</em>的k<em>个数</em>放到数组的前k个空间里。但是，这个问题没有说（1）要排好
- 海量数据中找到最大的100个数Java版
- //维持一个容量为100的小顶堆 public static int[] getTheMaxNums(int[] a){ int[] result = new int[100]; for(int i = 0;i&lt;100;i++){ result[i] = a[i]; } int len = result.length; for(int...
- 寻找TopN——在10亿数据中找到1000个最大的数
- 寻找TopN——在10亿数据中找到<em>1000</em>个<em>最大</em>的数目录问题描述解法补充 目录 问题描述 如何从10亿数据中找到前<em>1000</em>大的数？ 解法 针对该问题，给定一<em>个数</em>组data，从中<em>找出</em>前n个<em>最大</em>的数。 解题思路 先维护一个具有n<em>个数</em>的堆，然后调整该堆为小顶堆，即每个父节点都比其子节点小。然后从剩下的数组中逐一读取数据，将读取到的数据跟堆顶比较。如果该数比堆顶小，直接丢弃；如果该数比堆顶数大，则用该数替...
- 【面试现场】如何在10亿数中找出前1000大的数
- 小史是一个应届生，虽然学的是电子专业，但是自己业余时间看了很多互联网与编程方面的书，一心想进BAT互联网公司。 之前小史在BAT三家的面试中已经挂了两家，今天小史去了BAT中的最后一家面试了。 简单的自我介绍后，面试官给了小史一个问题。 【面试现场】 题目：如何在10亿数中<em>找出</em>前<em>1000</em>大的数？ 小史...
- 从一亿个数里找出最大的一万个数
- 这是一篇论文，用了六个方法求解问题，引导读者思考。最后得出极好的解。
- 100亿个数字找出最大的10个
- 1、首先一点，对于海量数据处理，思路基本上是确定的，必须分块处理，然后再合并起来。 2、对于每一块必须<em>找出</em>10个<em>最大</em>的数，因为第一块中10个<em>最大</em>数中的最小的，可能比第二块中10<em>最大</em>数中的<em>最大</em>的还要大。 3、分块处理，再合并。也就是Google MapReduce 的基本思想。Google有很多的服务器，每个服务器又有很多的CPU，因此，100亿<em>个数</em>分成100块，每个服务器处理一块，1亿...
- 100亿个数中找出最大的前K个数（海量TopK问题）
- 对于这个问题，可以有以下思考： 给了多少内存存储这100亿<em>个数</em>据？ 先思考：堆排序效率是nlogn,再思考：可以将这些数据切成等份，再从每一份中<em>找出</em><em>最大</em>前k<em>个数</em>据，但是效率不高。那如果利用堆的性质呢？ 小堆堆顶元素最小，先将前k<em>个数</em>建成小堆，那么堆顶元素就是最小的，k+1的数依次与堆顶元素进行比较，如果大于，则K+1与堆顶元素交换，依次循环直至所有数据全部比较完，那么这个堆里存放的是<em>最大</em>的前...
- 海量数据处理 - 10亿个数中找出最大的10000个数（top K问题）
- 前两天面试3面学长问我的这个问题（想说TEG的3个面试学长都是好和蔼，希望能完成最后一面，各方面原因造成我无比想去鹅场的心已经按捺不住了），这个问题还是建立最小堆比较好一些。 先拿<em>1000</em>0<em>个数</em>建堆，然后一次添加剩余元素，如果大于堆顶的数（<em>1000</em>0中最小的），将这<em>个数</em>替换堆顶，并调整结构使之仍然是一个最小堆，这样，遍历完后，堆中的<em>1000</em>0<em>个数</em>就是所需的<em>最大</em>的<em>1000</em>0个。建堆
- 谈从10亿个数中找出前10万个最大的
- 10亿个浮点数大概占据3G左右的空间，因此全部一次性读入内存目前在个人PC上是不太现实的。本次讨论不考虑内存等等，只考虑算法。 如果一次性比较排序，然后输出前面<em>最大</em>的10w个，那么众所周知，算法的时间复杂度不下于O(N lgN)，此处的N为数的<em>个数</em>（10亿）。 如果用堆排序，由于堆排序像合并排序而不像插入排序，堆排序的运行时间为O(N lgN);又想插入排序而不像合并排序，堆排
- 大数据算法面试：1亿数据在有限内存上如何排序
- 相信大家或多或少都看过一些算法类的面试题，其中比较常出现的就有大数据排序问题。因为目前的内存仍无法处理TB级的数据，只能通过不同的算法优化以及I/O来进行尽可能快速的排序。对于这类题目，我总结了以下几种排序方法，同时也提出了自己的一些疑问，希望大家可以一起讨论。这里只讨论nlogn级别的算法，其他的不列入讨论范围。题型：亿级别数据(同型且有重复)，统计其中出现次数最多的前N<em>个数</em>据两种情况：可一次读...
- 100亿个数取出最大的10000个
- 题目：100亿个整数，求<em>最大</em>的1万<em>个数</em>，并说出算法的时间复杂度 算法：如果把100亿<em>个数</em>全部读入内存，需要100 0000 0000 * 4B 大约40G的内存，这显然是不现实的。 我们可以在内存中维护一个大小为<em>1000</em>0的最小堆，每次从文件读一<em>个数</em>，与最小堆的堆顶元素比较，若比堆顶元素大， 则替换掉堆顶元素，然后调整堆。最后剩下的堆内元素即为<em>最大</em>的1万<em>个数</em>，算法复杂度为O(NlogN)
- 给定1亿int，找出最大的100个
- 给定1亿<em>个数</em>，<em>找出</em> <em>最大</em>的 100个 1. 用一个长度是 101 的数组，建立 小顶堆（0号元素不用，主要是为了使用堆的性质：父结点i，则，左右结点是 2i 和 2i+1） 2. 用堆顶 和 每个 取得的数 进行比较。（a. 堆顶 >= 取得的数，则，忽略 取得的数 b. 否则，把堆顶 替换为 取得的数） 3. 新得到的堆， 堆顶 的左右子树 都是 完美堆。需要调整 堆顶（调整算法 就是 构
- [面试题]海量数据处理-从10亿个数中找频率最高的1000个数
- 方法一：分治思想 通常比较好的方案是分治+Trie树/hash+小顶堆（就是上面提到的最小堆），即先将数据集按照Hash方法分解成多个小数据集，然后使用Trie树或者Hash统计每个小数据集中的query词频，之后用小顶堆求出每<em>个数</em>据集中出现频率最高的前K<em>个数</em>，最后在所有top K中求出最终的top K。 方法二：hadoop的map,reduce top K问题很适合采用MapReduce
- 100万个数中找最小的10个（利用快排思想，速度可观）
- 主要利用了快排的思想，划分解空间。 package net.bobo; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; public class MinTenNumbers { //1...
- 从100万个数中找出最大的前100个数
- https://blog.csdn.net/cslbupt/article/details/65935577 1.算法如下：根据快速排序划分的思想 (1) 递归对所有数据分成[a,b）b（b,d]两个区间，(b,d]区间内的数都是大于[a,b)区间内的数 (2) 对(b,d]重复(1)操作，直到最右边的区间<em>个数</em>小于100个。注意[a,b)区间不用划分 (3) 返回上一个区间，并返回此区间的数字数目...
- java创建大量随机的不重复的数
- 在面试的时候有时候会被问到这样的问题,如何在最短时间内创建50w条不重复且随机的数? 这里给出三个方法(方法肯定不止这三种) 1. 第一种,使用Set集合 利用Set集合不重复的特点,我们可以Random一<em>个数</em>,往Set中插入数据,直到Set集合的大小满足我们要的数量 public static void aa(int n){ Set r = new LinkedHashSet(n); ...
- 10亿个数中找出最大的10000个数
- 转载自 海量数据处理 - 10亿<em>个数</em>中<em>找出</em><em>最大</em>的<em>1000</em>0<em>个数</em>（top K问题） 前两天面试3面学长问我的这个问题（想说TEG的3个面试学长都是好和蔼，希望能完成最后一面，各方面原因造成我无比想去鹅场的心已经按捺不住了），这个问题还是建立最小堆比较好一些。 先拿<em>1000</em>0<em>个数</em>建堆，然后一次添加剩余元素，如果大于堆顶的数（<em>1000</em>0中最小的），将这<em>个数</em>替换堆顶，并...
- 海量数据处理 - 10亿个数中找出最大的10000个数（top K）
- 海量数据处理 - 10亿<em>个数</em>中<em>找出</em><em>最大</em>的<em>1000</em>0<em>个数</em>（top K问题） 版权声明：本文为博主原创文章，未经博主允许不得转载。 目录(?)[+] 前两天面试3面学长问我的这个问题（想说TEG的3个面试学长都是好和蔼，希望能完成最后一面，各方面原因造成我无比想去鹅场的心已经按捺不住了），这个问题还是建立最小堆比
- 从1亿个数里面找出前100个最大的
- 从1亿<em>个数</em>里面<em>找出</em>前100个<em>最大</em>的 这个题目应该是一些大公司面试题中经常被问到的，这里我给出一种做法，至于面试官满不满意我就不知道了。我们知道，这种<em>找出</em>前多少个<em>最大</em>或者最小的最适合用堆排序(对堆排序不熟悉的读者可以参考为的这篇博客：堆排序)。但是如果我们用1亿<em>个数</em>去建堆并调整，当然时间复杂度是不允许的。题目中要求前100个大的，那么我们就只用100...
- 编程实现希尔、快速、堆排序、归并排序算法。要求首先随机产生10000个数据存入磁盘文件，然后读入数据文件，分别采用不同的排序方法进行排序并将结果存入文件中。
- 编程实现希尔、快速、堆排序、归并排序算法。要求首先随机产生<em>1000</em>0<em>个数</em>据存入磁盘文件，然后读入数据文件，分别采用不同的排序方法进行排序并将结果存入文件中。一、算法思想描述（用一个长度为10的序列进行模拟）1.希尔排序希尔排序是对直接插入排序的改进，它利用了直接插入排序在序列<em>个数</em>少且基本有序的情况下排序效率较高的性质。首先获取整数d，将序列分出d个长度为d的子序列，选取中间（或中间靠后）的位置作为...
- 求解，找出10亿个个数字中的10000个最大值
- 要求算法精简，时间复杂度。
- 如何生成100个1-100以内的不重复的随机数
- 这是个经典的面试题目：生成长度为100的数组，插入1-100以内的但均不重复的随机数一、简单实现思路:(1) 把N<em>个数</em>放入Hashtable 或者arrayList 中.(2) 从上面的集合中随机抽取一<em>个数</em>放入int数组中.(3) 把取出的这<em>个数</em>从上面的集合中删除.(4) 循环 (2),(3) 步骤,直到int数组取满为止. 这是一种比较简单的实现思路，实现代码如下：import java.util
- 百度面试题：在100w个数中找最大的前100个数
- 在100w<em>个数</em>中找<em>最大</em>的前100<em>个数</em> 答案在文章评论部分，请注意查看:) 原文网址：http://hi.baidu.com/mianshiti/blog/item/37652f27a3ac4320d5074252.html -----------------
- 从一亿个数据里找前N个最大的数----算法源码
- 从一亿<em>个数</em>据里找前N个<em>最大</em>的数----算法源码，这里仅是思路之一的源码，更多详解和思路，请查看： 个人博客：http://blog.csdn.net/yanzi1225627 或：http://www.eyeandroid.com/thread-9596-1-1.html
- n个数里找出前m个数（或者 从10亿个浮点数中找出最大的1万个）
- 转载自：http://blog.csdn.net/winsunxu/article/details/6219376点击打开链接 引子 每年十一月各大IT公司都不约而同、争后恐后地到各大高校进行全国巡回招聘。与此同时，网上也开始出现大量笔试面试题；网上流传的题目往往都很精巧，既能让考查基础知识，又在平淡中隐含了广阔的天地供优秀学生驰骋。 这两天在网上淘到一1道笔试题目（注1），虽然
- 海量数据处理:有1亿个浮点数,找出其中最大的10000个
- 第一种方法是将数据全部排序,然后在排序后的集合中进行查找,最快的排序算法的时间复杂度一般为O(nlogn),例如快速排序.而在32位机器上,每个float类型占4B,1亿个浮点数就要占用400M的存储空间,对于一些可以内存小于400MB的计算机而言,显然是不能一次将全部数据读入内存进行排序的.其实即使内存能满足要求,该方法也不高效,因为题目的目的是寻<em>找出</em><em>最大</em>的<em>1000</em>0<em>个数</em>即可,而排序是将所有元素...
- 《算法导论》学习之关于如何利用排序算法，从1亿个数中，选出最大（小）的100个数
- 首先声明：本文内容是参考别人的博客，链接为：http://blog.csdn.net/beiyeqingteng/article/details/7534489 前言： 刚刚在CSDN上看到一个网友利用最小堆实现 “ 获取一亿数据获取前100个<em>最大</em>值” 。原帖请看：http://blog.csdn.net/yjflinchong/article/details/7533972。
- 转：如何在 10 亿数中找出前 1000 大的数？
- 原文链接：https://mp.weixin.qq.com/s/SHmoBNduRYOf5yO87Q9yWQ 典型的TopN问题，有以下几种思路，详细描述请参考原文链接： 1）全部排序后取前N<em>个数</em>：时间复杂度太高 2）部分排序：时间复杂度太高 3）分治法：时间复杂度为O（n），但Partition时占用内存空间过大 4）分布式计算：先将数据分组，每个分组中计算TopN，然后汇总所有的To...
- 从10万个数中找10个最大的数
- 对于这种题目，最普通的想法是先对这10万<em>个数</em>进行排序，然后再选取数组中前10<em>个数</em>，即为最后的答案，排序算法的时间复杂度不下于O(N lgN)。最好的方法是建立一个最小堆。 算法描述： 我们首先取10万个元素中的前10个元素来建立由10个元素组成的最小堆。这样堆顶元素便是当前已知元素的第10大的数；然后依次读取剩下的99990个元素，若读取的元素比堆顶元素大，则将堆顶元素和当前元素替换，并自堆顶至
- 从大量数据中取最小的前k个数
- 问题描述：从大量整数中，取前k个最小的数 思路描述： 1.利用<em>最大</em>堆性质，根节点的数据<em>最大</em>。 2.首先读取k<em>个数</em>据，构造大小为k+1的<em>最大</em>堆。（有效索引为1-k） 3.每次读取一<em>个数</em>据，若该数比<em>最大</em>堆的第一<em>个数</em>据小，则将该数据最为<em>最大</em>堆的第一<em>个数</em>，然后执行Max_Heapfy函数维护<em>最大</em>堆得性质。 4.数据读取结束，该堆中的数据为最小的k<em>个数</em> 5.对该堆进行排序，从小到大进行排序后输出。
- 10亿数据中取最大的100个数据
- 思路1：根据快速排序划分的思想 （1）递归对所有数据分成[a,b）b（b,d]两个区间，(b,d]区间内的数都是大于[a,b)区间内的数 （2）对(b,d]重复(1)操作，直到最右边的区间<em>个数</em>小于100个。注意[a,b)区间不用划分 （3）返回上一个区间，并返回此区间的数字数目。接着方法仍然是对上一区间的左边进行划分，分为[a2,b2）b2（b2,d2]两个区间，取（b2,d2]区间。如果
- 如何从100万个数中找出最大的前100个数
- 摘自 http://blog.sina.com.cn/s/blog_682686610100xlrr.html 1. 算法如下：根据快速排序划分的思想 (1) 递归对所有数据分成[a,b）b（b,d]两个区间，(b,d]区间内的数都是大于[a,b)区间内的数 (2) 对(b,d]重复(1)操作，直到最右边的区间<em>个数</em>小于100个。注意[a,b)区间不用划分 (3) 返回上
- 100万个数中找到最大的100个数
- 1. 算法如下：根据快速排序划分的思想 (1) 递归对所有数据分成[a,b）b（b,d]两个区间，(b,d]区间内的数都是大于[a,b)区间内的数 (2) 对(b,d]重复(1)操作，直到最右边的区间<em>个数</em>小于100个。注意[a,b)区间不用划分 (3) 返回上一个区间，并返回此区间的数字数目。接着方法仍然是对上一区间的左边进行划分，分为[a2,b2）b2（b2,d2]两个区间，取（b2,d2]区间
- 【数据结构】找出N个数据中最大的前k个数据（利用堆排序）
- 我们举例，假若从<em>1000</em>0万<em>个数</em>里选出前100个<em>最大</em>的数据。首先我们先分析：既然要选出前100个<em>最大</em>的数据，我们就建立一个大小为100的堆（建堆时就按找<em>最大</em>堆的规则建立，即每一个根节点都大于它的子女节点），然后再将后面的剩余数据若符合要求就插入堆中，不符合就直接丢弃该数据。那我们现在考虑：确定是该选择<em>最大</em>堆的数据结构还是最小堆的数据结构呢。分析一下：若选用<em>最大</em>堆的话，堆顶是堆的<em>最大</em>值，我们考虑既然
- 100万个数据里面找出100个最大的
- 参考博客： https://blog.csdn.net/beiyetengqing/article/details/8011792 /*基于quicksort实现的原理如下： 1. 假设数组为 array[N] (N = 1 亿)，首先利用quicksort的原理把array分成两个部分，左边部分比 array[N - 1] (array中的最后一个值，即pivot) 大， 右边部分比pi...
- 腾讯面试题：一亿数字获取前100个最大的数字办法
- 比较笨的办法。效率有点低。 只是实现了功能。 期待牛人的算法。 我弄了个最佳方案 http://blog.csdn.net/yjflinchong/article/details/7533972 3秒就搞定了 一亿数字获取前100个<em>最大</em>的数字 这个方案需要700秒 ///http://blog.csdn.net/yjflinchong/article/details/7532018 ...
- 从1000个数中选择出10个最大的数
- 我这个是数量小，如果数量大些有什么办法还没想到 [code="java"] public static Set getTop100(int[] inputArray) { TreeSet top100 = new TreeSet(); for (int i = 0; i < inputArray.length; i++) { if (top100.size() < 10)...
- 从100万个整数里找出100个最大的数
- 100万个整数里<em>找出</em>100个<em>最大</em>的数（用哪种算法效率高） 以下为可能性<em>最大</em>的答案：部分排序？<em>找出</em>一个支点，把数组分为左右，一直分... 可以参考一下STL中nth_element的实现吧。选择第k大数有O(n)的算法，过程衍生自快排呵呵我看懂啦，是个好算法！顶！ 取前100<em>个数</em>排序,放入链表中.依次取后面的数与100<em>个数</em>的最小数比较,若取到的数比最小数大,则插入链表中,同时挤掉最小的数.这个过程中使用的链表,因为
- 一亿数据获取最大值的前100位
- 两种思路： 1. 根据快速排序划分的思想 a. 假设数组为 array[N] (N = 1 亿)，首先利用quicksort的原理把array分成两个部分，左边部分比 array[N - 1] (array中的最后一个值，即pivot) 大， 右边部分比pivot 小。然后，可以得到 array[array.length - 1] (即 pivot) 在整<em>个数</em>组中的位置，假设是 k.
- 在1000个数中找出前五十大的数
- public class Tree { //父节点 private int parent(int n){ return (n-1)/2; } //左孩子 private int left(int n){ return 2*n+1; } //右孩子 private int right(int n){ return 2*n+2; } //构建堆 private voi...
- FragmentDome,包括嵌套viewpager，Fragment多层嵌套下载
- FragmentDome,完整的Dome，其包扩fragment的多层嵌套，并且使用viewpager嵌套多层fragment，并且实现活动和点击的完美效果，另外还添加滑动时的动画效果 相关下载链接：[url=//download.csdn.net/download/u013179982/8384399?utm_source=bbsseo]//download.csdn.net/download/u013179982/8384399?utm_source=bbsseo[/url]
- 集合了众多动画特效的VC++窗体附源代码下载
- 别看这个程序主界面很普通，实际上你每点一个菜单，它都有一种动画窗体特效出现，包括VS界面，各种TAB、TREE，弹出窗，右下角提示，树控菜单等，全面剖析这个源码实例，你会得到不少实用的技巧。 相关下载链接：[url=//download.csdn.net/download/andyjiang2008/1998780?utm_source=bbsseo]//download.csdn.net/download/andyjiang2008/1998780?utm_source=bbsseo[/url]
- .net中EXCEL上传到数据库完整版下载
- 实用时修改类中的连接串即可实现,其中ceshi.aspx是我测试用的，而default.aspx才是真正实现，请直接实用default.aspx页面 相关下载链接：[url=//download.csdn.net/download/haosiniba/2073238?utm_source=bbsseo]//download.csdn.net/download/haosiniba/2073238?utm_source=bbsseo[/url]
我们是很有底线的