10亿个数中找出最大的10000个数（top K问题）

这个问题仍是创建最小堆比较好一些。

        先拿10000个数建堆，而后一次添加剩余元素，若是大于堆顶的数（10000中最小的），将这个数替换堆顶，并调整结构使之仍然是一个最小堆，这样，遍历完后，堆中的10000个数就是所需的最大的10000个。建堆时间复杂度是O（mlogm），算法的时间复杂度为O（nmlogm）（n为10亿，m为10000）。

        优化的方法：能够把全部10亿个数据分组存放，好比分别放在1000个文件中。这样处理就能够分别在每一个文件的10^6个数据中找出最大的10000个数，合并到一块儿在再找出最终的结果。

        以上就是面试时简单提到的内容，下面整理一下这方面的问题：

top K问题

        在大规模数据处理中，常常会遇到的一类问题：在海量数据中找出出现频率最好的前k个数，或者从海量数据中找出最大的前k个数，这类问题一般被称为top K问题。例如，在搜索引擎中，统计搜索最热门的10个查询词；在歌曲库中统计下载最高的前10首歌等。

        针对top K类问题，一般比较好的方案是分治+Trie树/hash+小顶堆（就是上面提到的最小堆），即先将数据集按照Hash方法分解成多个小数据集，而后使用Trie树活着Hash统计每一个小数据集中的query词频，以后用小顶堆求出每一个数据集中出现频率最高的前K个数，最后在全部top K中求出最终的top K。

eg：有1亿个浮点数，若是找出期中最大的10000个？

        最容易想到的方法是将数据所有排序，而后在排序后的集合中进行查找，最快的排序算法的时间复杂度通常为O（nlogn），如快速排序。可是在32位的机器上，每一个float类型占4个字节，1亿个浮点数就要占用400MB的存储空间，对于一些可用内存小于400M的计算机而言，很显然是不能一次将所有数据读入内存进行排序的。其实即便内存可以知足要求（我机器内存都是8GB），该方法也并不高效，由于题目的目的是寻找出最大的10000个数便可，而排序倒是将全部的元素都排序了，作了不少的无用功。

        第二种方法为局部淘汰法，该方法与排序方法相似，用一个容器保存前10000个数，而后将剩余的全部数字——与容器内的最小数字相比，若是全部后续的元素都比容器内的10000个数还小，那么容器内这个10000个数就是最大10000个数。若是某一后续元素比容器内最小数字大，则删掉容器内最小元素，并将该元素插入容器，最后遍历完这1亿个数，获得的结果容器中保存的数即为最终结果了。此时的时间复杂度为O（n+m^2），其中m为容器的大小，即10000。

        第三种方法是分治法，将1亿个数据分红100份，每份100万个数据，找到每份数据中最大的10000个，最后在剩下的100*10000个数据里面找出最大的10000个。若是100万数据选择足够理想，那么能够过滤掉1亿数据里面99%的数据。100万个数据里面查找最大的10000个数据的方法以下：用快速排序的方法，将数据分为2堆，若是大的那堆个数N大于10000个，继续对大堆快速排序一次分红2堆，若是大的那堆个数N大于10000个，继续对大堆快速排序一次分红2堆，若是大堆个数N小于10000个，就在小的那堆里面快速排序一次，找第10000-n大的数字；递归以上过程，就能够找到第1w大的数。参考上面的找出第1w大数字，就能够相似的方法找到前10000大数字了。此种方法须要每次的内存空间为10^6*4=4MB，一共须要101次这样的比较。

        第四种方法是Hash法。若是这1亿个书里面有不少重复的数，先经过Hash法，把这1亿个数字去重复，这样若是重复率很高的话，会减小很大的内存用量，从而缩小运算空间，而后经过分治法或最小堆法查找最大的10000个数。

        第五种方法采用最小堆。首先读入前10000个数来建立大小为10000的最小堆，建堆的时间复杂度为O（mlogm）（m为数组的大小即为10000），而后遍历后续的数字，并于堆顶（最小）数字进行比较。若是比最小的数小，则继续读取后续数字；若是比堆顶数字大，则替换堆顶元素并从新调整堆为最小堆。整个过程直至1亿个数所有遍历完为止。而后按照中序遍历的方式输出当前堆中的全部10000个数字。该算法的时间复杂度为O（nmlogm），空间复杂度是10000（常数）。

实际运行：

        实际上，最优的解决方案应该是最符合实际设计需求的方案，在时间应用中，可能有足够大的内存，那么直接将数据扔到内存中一次性处理便可，也可能机器有多个核，这样能够采用多线程处理整个数据集。

       下面针对不容的应用场景，分析了适合相应应用场景的解决方案。

（1）单机+单核+足够大内存

        若是须要查找10亿个查询次（每一个占8B）中出现频率最高的10个，考虑到每一个查询词占8B，则10亿个查询次所需的内存大约是10^9 * 8B=8GB内存。若是有这么大内存，直接在内存中对查询次进行排序，顺序遍历找出10个出现频率最大的便可。这种方法简单快速，使用。而后，也能够先用HashMap求出每一个词出现的频率，而后求出频率最大的10个词。

（2）单机+多核+足够大内存

        这时能够直接在内存总使用Hash方法将数据划分红n个partition，每一个partition交给一个线程处理，线程的处理逻辑同（1）相似，最后一个线程将结果归并。

        该方法存在一个瓶颈会明显影响效率，即数据倾斜。每一个线程的处理速度可能不一样，快的线程须要等待慢的线程，最终的处理速度取决于慢的线程。而针对此问题，解决的方法是，将数据划分红c×n个partition（c>1），每一个线程处理完当前partition后主动取下一个partition继续处理，知道全部数据处理完毕，最后由一个线程进行归并。

（3）单机+单核+受限内存

        这种状况下，须要将原数据文件切割成一个一个小文件，如次啊用hash(x)%M，将原文件中的数据切割成M小文件，若是小文件仍大于内存大小，继续采用Hash的方法对数据文件进行分割，知道每一个小文件小于内存大小，这样每一个文件可放到内存中处理。采用（1）的方法依次处理每一个小文件。

（4）多机+受限内存

        这种状况，为了合理利用多台机器的资源，可将数据分发到多台机器上，每台机器采用（3）中的策略解决本地的数据。可采用hash+socket方法进行数据分发。

 

        从实际应用的角度考虑，（1）（2）（3）（4）方案并不可行，由于在大规模数据处理环境下，做业效率并非首要考虑的问题，算法的扩展性和容错性才是首要考虑的。算法应该具备良好的扩展性，以便数据量进一步加大（随着业务的发展，数据量加大是必然的）时，在不修改算法框架的前提下，可达到近似的线性比；算法应该具备容错性，即当前某个文件处理失败后，能自动将其交给另一个线程继续处理，而不是从头开始处理。

        top K问题很适合采用MapReduce框架解决，用户只需编写一个Map函数和两个Reduce 函数，而后提交到Hadoop（采用Mapchain和Reducechain）上便可解决该问题。具体而言，就是首先根据数据值或者把数据hash(MD5)后的值按照范围划分到不一样的机器上，最好可让数据划分后一次读入内存，这样不一样的机器负责处理不一样的数值范围，实际上就是Map。获得结果后，各个机器只需拿出各自出现次数最多的前N个数据，而后汇总，选出全部的数据中出现次数最多的前N个数据，这实际上就是Reduce过程。对于Map函数，采用Hash算法，将Hash值相同的数据交给同一个Reduce task；对于第一个Reduce函数，采用HashMap统计出每一个词出现的频率，对于第二个Reduce 函数，统计全部Reduce task，输出数据中的top K便可。

        直接将数据均分到不一样的机器上进行处理是没法获得正确的结果的。由于一个数据可能被均分到不一样的机器上，而另外一个则可能彻底汇集到一个机器上，同时还可能存在具备相同数目的数据。

 

如下是一些常常被说起的该类问题。

（1）有10000000个记录，这些查询串的重复度比较高，若是除去重复后，不超过3000000个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门。请统计最热门的10个查询串，要求使用的内存不能超过1GB。

（2）有10个文件，每一个文件1GB，每一个文件的每一行存放的都是用户的query，每一个文件的query均可能重复。按照query的频度排序。

（3）有一个1GB大小的文件，里面的每一行是一个词，词的大小不超过16个字节，内存限制大小是1MB。返回频数最高的100个词。

（4）提取某日访问网站次数最多的那个IP。

（5）10亿个整数找出重复次数最多的100个整数。

（6）搜索的输入信息是一个字符串，统计300万条输入信息中最热门的前10条，每次输入的一个字符串为不超过255B，内存使用只有1GB。

（7）有1000万个身份证号以及他们对应的数据，身份证号可能重复，找出出现次数最多的身份证号。

 

重复问题

        在海量数据中查找出重复出现的元素或者去除重复出现的元素也是常考的问题。针对此类问题，通常能够经过位图法实现。例如，已知某个文件内包含一些电话号码，每一个号码为8位数字，统计不一样号码的个数。

        本题最好的解决方法是经过使用位图法来实现。8位整数能够表示的最大十进制数值为99999999。若是每一个数字对应于位图中一个bit位，那么存储8位整数大约须要99MB。由于1B=8bit，因此99Mbit折合成内存为99/8=12.375MB的内存，便可以只用12.375MB的内存表示全部的8位数电话号码的内容。

 

算法一：冒泡排序法

　　千里之行，始于足下。咱们先不说最好，甚至不说好。咱们只问，如何“从10000个整数中找出最大的10个”？我最早想到的是用冒泡排序的办法：咱们从头至尾走10趟，天然会把最大的10个数找到。方法简单，就再也不这里写代码了。这个算法的复杂度是10N（N=10000）。

算法二：

　　有没有更好一点的算法呢？固然。维持一个长度为10的降序数组，每个从数组拿到的数字都与这个降序数组的最小值比较。若是小于最小值，就舍弃；若是大于最小值，就把它插入到降序数组中的合适位置，舍弃原来的最小值。这样，遍历一遍就能够找到最大的10个数。由于须要在降序数组中插入一个数，对于遍历的每一个数可能都须要这样，因此其复杂为5N。

　　伪代码以下：

　　A[N]，a[m]（分别为原始数组和降序数组，其中N=10000，m=10）

　　a = A[0 ... 9]（将数组A的前10个数赋给数组a）

　　sort a（将组数a降序排序）

　　for i in A[ 10 ... N]（从10到N遍历数组A）

　　　　if A[i] > a[9] then （若是当前值比降序数组中的最小值大）

　　　　　　删除a[9]

　　　　　　将A[i]插入a的合适位置，使a保持降序

　　　　end if

　　end for

　　输出数组a

　　其实算法二还有一个优势，就是当数组很大时，能够将数据分段读入内存处理，而这样作并不影响结果。

 

一、首先一点，对于海量数据处理，思路基本上是肯定的，必须分块处理，而后再合并起来。

二、对于每一块必须找出10个最大的数，由于第一块中10个最大数中的最小的，可能比第二块中10最大数中的最大的还要大。

三、分块处理，再合并。也就是Google MapReduce 的基本思想。Google有不少的服务器，每一个服务器又有不少的CPU，所以，100亿个数分红100块，每一个服务器处理一块，1亿个数分红100块，每一个CPU处理一块。而后再从下往上合并。注意：分块的时候，要保证块与块之间独立，没有依赖关系，不然不能彻底并行处理，线程之间要互斥。另一点，分块处理过程当中，不要有反作用，也就是不要修改原数据，不然下次计算结果就不同了。

四、上面讲了，对于海量数据，使用多个服务器，多个CPU能够并行，显著提升效率。对于单个服务器，单个CPU有没有意义呢？

　　也有很大的意义。若是不分块，至关于对100亿个数字遍历，做比较。这中间存在大量的没有必要的比较。能够举个例子说明，全校高一有100个班，我想找出全校前10名的同窗，很傻的办法就是，把高一100个班的同窗成绩都取出来，做比较，这个比较数据量太大了。应该很容易想到，班里的第11名，不多是全校的前10名。也就是说，不是班里的前10名，就不多是全校的前10名。所以，只须要把每一个班里的前10取出来，做比较就好了，这样比较的数据量就大大地减小了。

以前看到一个面试题，1000个乱序正整数中找出10个最小值，要求高效快速，不能使用API。

              这学期学了些排序的方法，什么快速排序啊，冒泡啊，归并排序啊之类的。看到这个题的时候，第一反应是快速排序，由于它的名字叫快速嘛，应该够快吧。而后又想到这个题目不是要你完整的排序，只须要求出最小的10个就够了，那么冒泡法呢？冒泡法只冒前面10个数？

             发现这样子仍是要遍历比较1000*10次。

             而后，利用相似于数据结构里的栈的特性？把这1000个数的前10个放到一个数组种，排好序，而后，剩下的990个数字，每一个都与这10个数的最大数比较，大于则不考虑，小于就把最大值拿出来，把这个数放进去，这样的话，冒泡排序的比较次数就变成了990次，好像高效不少哦？

             将题目里的1000和10设定为由用户输入的n和m，产生了个人下面这个程序（没有考虑m>n的状况）

 

[java] import java.util.Random;  import java.util.Scanner;        public class Main {        private static int n;      private static int m;      private static int []num;      private static int []min;      static Scanner in = new Scanner(System.in);            public static void main(String[] args) {          int con = 1;          while(con == 1) {              getAns();              System.out.println("\nContinue?(0:No; 1:Yes)");              con = in.nextInt();          }      }            public static void getAns() {          System.out.println("Enter n and m :");          n = in.nextInt();          m = in.nextInt();          num = new int[n];             min = new int[m];                    //随机生成n个整数并让前m个数默认为是这n个数中最小的m个数           Random rand = new Random();          for(int i = 0; i < n; i++) {              num[i] = rand.nextInt((int) Math.pow(2, 10));              if(i < m) {                  min[i] = num[i];              }                        }          //冒泡排序，对前m个数顺序排列           sort1();                    //求的这最小的m个数           getMin();                    System.out.println("m个最小值分别为 :");          for(int i = 0; i < m; i++) {              System.out.print(min[i] + "\t");              if((i+1) % 10 == 0) {                  System.out.println();              }          }      }            public static void sort1() {          int temp;          int k;          for(int i = 0; i < m; i++) {              temp = i;              for(int j = i+1; j < m; j++) {                  if(min[temp] > min[j]) {                      temp = j;                  }              }              if(temp != i) {                  k = min[temp];                  min[temp] = min[i];                  min[i] = k;              }          }      }            public static void getMin() {          int temp;          for(int i = m; i < n; i++) {              if(num[i] < min[m-1]) {                  temp = num[i];                  num[i] = min[m-1];                  min[m-1] = temp;                  //更换了数据以后，高效率的从新让数据顺序排列                   sort2();              }          }      }            //比最大者小的数放在最大值的位置，此时要想办法将这个数放在合适的位置       public static void sort2() {          int x = m - 1;          int temp;          while(x > 0 && min[x] < min[x-1]) {              temp = min[x];              min[x] = min[x-1];              min[x-1] = temp;              x--;          }      }    }