海量数据处理

常用的数据结构：

1.Bloom Filter
      大致思想是这样，把一个数据通过N个哈希函数映射到一个长度为M的数组的一位上，将hash函数对应的值的位数组置1，查找时如果发现所有hash函数对应位都是1说明该数据的存在。但不能保证完全正确性，但是此方法无比高效。
2.哈希法
      这个简单，无非是通过一些哈希函数把元素搞到一个指定的位置，简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
3.最大或最小堆
      就是一个完全的最大或最小二叉树，用途，比如: 100w个数中找最大的前100个数。用一个100个元素大小的最小堆即可。
4.Bit-map
      所谓的Bit-map就是用一个bit位来标记某个元素对应的Value， 而Key即是该元素。由于采用了Bit为单位来存储数据，因此在存储空间方面，可以大大节省。
     1>BitMap的功能：
         1：排序
         2：判断一组数据中是否有重复出现的数据
     2>Bloom Filter的功能：BitMap的进阶，大数据量判重。

情景1：对无重复的数据进行排序数据（2，4，1，12，9，7，6）如何排序？
      方法1：基本的排序方法包括冒泡，快排等。 
      方法2：BitMap算法
      方法2中所谓的BitMap是一个位数组，跟平时使用的数组的唯一差别在于操作的是位。首先是开辟2个字节大小的位数组，长度为16（该长度由上述数据中最大的数字12决定的）,然后，读取数据，2存放在位数组中下标为1的地方，值从0改为1，4存放在下标为3的地方，值从0改为1… 最后，读取该位数组，得到排好序的数据是：（1，2，4，6，7，9，12）。
      比较方法1和方法2的差别：方法2中，排序需要的时间复杂度和空间复杂度很依赖与数据中最大的数字比如12，因此空间上讲需要开2个字节大小的内存，时间上需要遍历完整个数组。当数据类似（1，1000，10万）只有3个数据的时候，显然用方法2，时间复杂度和空间复杂度相当大，但是当数据比较密集时该方法就会显示出来优势。

情景2：对有重复的数据进行判重
      数据：（2，4，1，12，2，9，7，6，1，4）如何找出重复出现的数字？
      首先是开辟2个字节大小的位数组，长度为16（该长度由上述数据中最大的数字12决定的），当读取2的时候，发现数组中的值是1，则判断出2是重复出现的。
      应用1：某文件中包含一些8位的电话号码，统计出现的号码的个数？ （判断有谁出现）8位最大是99 999 999，大约是99M的bit，12.5MB的内存，就可以统计出来出现的号码。
      应用2：某文件中包含一些8位的电话号码，统计只出现一次的号码？ （判断有谁出现并且指出现1次）需要扩展一下，可以用两个bit表示一个号码，0代表没有出现过，1代表只出现过1次，2代表至少出现2次。 
      应用3：有两个文件，文件1中有1亿个10位的qq号码，文件2中有5千万个10位qq号码，判断两个文件中重复出现的qq号。首先建立10的10次方个大小的位数组（占用内存大约是1.25G），全部初始化为0，读取第一个文件，对应的qq号存放到对应的未知，数值改为1，如果重复出现仍是1.读取完毕第一个文件后，读取第二个文件，对应的位置为1则表示重复出现。
      应用4：有两个文件，文件1中有1亿个15位的qq号码，文件2中有5千万个15位的qq号码，判断两个文件中重复出现的qq号。  
 
      Bloom Filter：对于Bit-Map分析一下，每次都会开辟一块表示最大数值大小的bit数组，比如情景1中的16，将对应的数据经过映射到bit数组的下标，这其实是一种最简单的hash算法，对1去模。在上述应用4中，当qq号码改为15位的时候，Bit-Map就不太好用了，如何改进呢？ 解决办法：减少bit数组的长度，但是增加hash函数的个数对于每一个qq号码，我用K个hash函数，经过k次映射，得到k个不同位置，假设k=3，那么对于一个qq号码，映射到位数组中3个不同的位置。当读取第二个包含5千万个qq号码的文件的时候，使用同样的3个hash函数进行映射，当3个位置全部是1的时候才表示出现过，否则表示没有出现过。
      有什么疑问吗？
      显然，对于一个qq号码，如果它在第一个文件中没有出现过，但是它映射的3个位置已经全部是1的情况会有吗？答案是会的，但是这种概率是可控的，可控的意思是：这种误差跟hash函数的个数和质量是有关系的，可以通过控制hash函数的个数和位数组的大小来控制误差概率。至于表示3者之间的关系精确的数学公式就不再详细研究了 。
      可以这样讲，布隆过滤器是Bit-Map的进一步扩展，对于大数据量判重，布隆过滤器可以在内存中进行判断，避免了对磁盘的读写，效率是很高的。 

1．假设一个文件中有9亿条不重复的9位整数，现在要求对这个文件进行排序。 

      一般解题思路: 
      1、将数据导入到内存中 
      2、将数据进行排序（比如插入排序、快速排序） 
      3、将排序好的数据存入文件
     难题:一个整数为4个字节，即使使用数组也需要900,000,000 * 4byte = 3.4G内存，对于32位系统，访问2G以上的内存非常困难，而且一般设备也没有这么多的物理内存，将数据完全导入到内存中的做法不现实。
     其他解决办法: 
      1、导入数据库运算 
      2、分段排序运算 
      3、使用bit位运算 

     解决方案一:数据库排序,将文本文件导入到数据库，让数据库进行索引排序操作后提取数据到文件
     优点：操作简单 
     缺点：运算速度慢，而且需要数据库设备。 

     解决方案二:分段排序,操作方式：规定一个内存大小，比如200M，200M可以记录(200*1024*1024/4) = 52428800条记录，可以每次提取5000万条记录到文件进行排序，要装满9位整数需要20次，所以一共要进行20次排序，需要对文件进行20次读操作 
     缺点：编码复杂，速度也慢(至少20次搜索)
     关键步骤：先将整个9位整数进行分段，亿条数据进行分成20段，每段5000万条，在文件中依次搜索0~5000万，50000001~1亿……将排序的结果存入文件

     解决方案三:bit位操作
     思考下面的问题:一个最大的9位整数为999999999，这9亿条数据是不重复的，可不可以把这些数据组成一个队列或数组，让它有0~999999999(10亿个)元素 ，数组下标表示数值，节点中用0表示这个数没有，1表示有这个数 ，判断0或1只用一个bit存储就够了。声明一个可以包含9位整数的bit数组(10亿)，一共需要10亿/8=120M内存。把内存中的数据全部初始化为0, 读取文件中的数据，并将数据放入内存。比如读到一个数据为341245909这个数据，那就先在内存中找到341245909这个bit，并将bit值置为1遍历整个bit数组，将bit为1的数组下标存入文件 。

2.对2亿条手机号码删除重复记录(过滤号码黑名单同样有效) 

      工作难点就在于如何处理这2亿条电话号码,直接用哈希表存放手机号码不大现实,即使经过优化,用一个unsigned int存放一条记录,那也得需要2亿*4=8亿byte,远超过32位系统的寻址能力 
      解决方案: 将电话号码由12位单个数字组成的字符串转换为一个unsigned int型数据(手机号码由前三位数字和后面八位数字组成,后面八位需要占到1~1000万的空间,而前面用0~100的数字存储已经足够)为简单起见,默认为0~4G的数字都有可能分布号码,为此我们分配4G/32=512M的内存将这2亿个号码整理成unsigned int类型后按上述办法存放在这块内存中(比如13512345678整理后为112345678,找到内存中112345678bit的下标,并将此bit值设为1)遍历整个bit数组,记录下所有的号码,这些号码即是不重复的手机号码
     总结：
     建立一个足够大的bit数组当作hash表
     以bit数组的下标来表示一个整数
     以bit位中的0或1来表示这个整数是否在这个数组中存在
     适用于无重复原始数据的搜索
     原来每个整数需要4byte空间变为1bit，空间压缩率为32倍
     扩展后可实现其他类型（包括重复数据）的搜索 
 

3.3000w数据的表，取某项字段前50项数据 ，内存2G

       大体实现思路是这样子的，3000w的数据划分为1000段，也就是1-3w为一段，30001-6w项为第二段，依次类推，从每3w的数据中提取出前50条数据（这个根据sql排序就能取出来，2个g的内存够了），最后1000个50就会产生5w个数据，最后提取出来的5w的数据放置到ArrayList中去，最后5w的数据统一排序，取出前50条。5w*5w的对比与交换是可以搞定的。

4．对所有139段的号码进行统计排序

      已经发放的139号码段的文件都存放在一个文本文件中，一个号码一行，现在需要将文件里的所有号码进行排序，并写入到一个新的文件中；号码可能会有很多，最多可能有一亿个不同的号码（所有的139段号码），存入文本文件中大概要占1.2G的空间；jvm最大的内存在300以内，程序要考虑程序的可执行性及效率。
      这是个典型的大数据量的排序算法问题，首先要考虑空间问题，一下把1.2G的数据读入内存是不太可能的，就算把一亿条数据，转都转换成int类型存储也要占接近400M的空间。基本思想是原文件分割成若干个小文件并排序，再将排序好的小文件合并得到最后结果，算法大概如下： 
      1.顺序读取存放号码文件的中所有号码，并取139之后的八位转换为int类型；每读取号码数满一百万个，（这个数据可配置）将已经读取的号码排序并存入新建的临时文件。 
      2.将所有生成的号码有序的临时文件合并存入结果文件。 
     这个算法虽然解决了空间问题，但是运行效率极低，由于IO读写操作太多，加上步骤1中的排序的算法（快速排序）本来效率就不高（对于电话排序这种特殊情况来说），导致1亿条数据排序运行3个小时才有结果。 
     如果和能够减少排序的时间呢？首当其冲的减少IO操作，另外如果能够有更加好排序算法也行。使用是位向量（实际上就是一个bit数组），用电话作为index：用位向量存储电话号码，一个号码占一个bit，一亿个电话号码也只需要大概12M的空间；算法大概如下： 
     1.初始化bits[capacity]；
     2.顺序所有读入电话号码，并转换为int类型，修改位向量值：bits[phoneNum]=1； 
     3.遍历bits数组，如果bits[index]=1，转换index为电话号码输出。

5. 设计DNS服务器中cache的数据结构

     要求设计一个DNS的Cache结构，要求能够满足每秒5000以上的查询，满足IP数据的快速插入，查询的速度要快。（站点数总共为5000万，IP地址有1000万，等等）
     DNS服务器实现域名到IP地址的转换。每个域名的平均长度为25个字节（估计值），每个IP为4个字节，所以Cache的每个条目需要大概30个字节。总共50M个条目，所以需要1.5G个字节的空间。可以放置在内存中。（考虑到每秒5000次操作的限制，也只能放在内存中。）
     可以考虑的数据结构包括hash_map，字典树，红黑树等等。
     比较好的解决方法是，将每一个URL字符串转化为MD5值，作为key，建立最大或最小堆，这样插入和查找的效率都是O(log(n))。MD5是128bit的大整数也就是16byte，比直接存放URL要节省的多。

6. 服务器内存 1G，有一个 2G 的文件，里面每行存着一个 QQ 号（5-10位数），怎么最快找出出现最多次的 QQ 号

      首先要注意到，数据存在服务器，存储不了（内存存不了），要想办法统计每一个qq出现的次数。比如，因为内存是1g，首先用hash的方法，把qq分配到10 个（这个数字可以变动）文件（在硬盘中）。相同的 qq 肯定在同一个文件中，然后对每一个文件，只要保证每一个文件少于 1g 的内存，统计每个 qq 的次数，可以使用 hash_map(qq, qq_count)实现。然后，记录每个文件的最大访问次数的 qq，最后，从 10 个文件中找出一个最大，即为所有的最大。

7. 海量日志数据，提取出某日访问百度次数最多的那个IP

      首先是这一天，并且是访问百度的日志中的IP取出来，逐个写入到一个大文件中。注意到IP是32位的，最多有个2^32个IP。同样可以采用映射的方法，比如模1000，把整个大文件映射为1000个小文件，再找出每个小文中出现频率最大的IP（可以采用hash_map进行频率统计，然后再找出频率最大的几个）及相应的频率。然后再在这1000个最大的IP中，找出那个频率最大的IP，即为所求。
      算法思想：分而治之+Hash
      1.IP地址最多有2^32=4G种取值情况，所以不能完全加载到内存中处理；
      2.可以考虑采用“分而治之”的思想，按照IP地址的Hash(IP)%1024值，把海量IP日志分别存储到1024个小文件中。这样，每个小文件最多包含4MB个IP地址；
      3.对于每一个小文件，可以构建一个IP为key，出现次数为value的Hash map，同时记录当前出现次数最多的那个IP地址；
      4.可以得到1024个小文件中的出现次数最多的IP，再依据常规的排序算法得到总体上出现次数最多的IP；

8. 日志文件一千万个记录，统计最热门的10个查询串

       搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。假设目前有一千万个记录（这些查询串的重复度比较高，虽然总数是1千万，但如果除去重复后，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门。），请你统计最热门的10个查询串，要求使用的内存不能超过1G
       第一步、先对这批海量数据预处理，在O（N）的时间内用Hash表完成统计；
       第二步、借助堆这个数据结构，找出Top K，时间复杂度为N‘logK。
       即借助堆结构，可以在log量级的时间内查找和调整/移动。因此，维护一个K(该题目中是10)大小的小根堆，然后遍历300万的Query，分别和根元素进行对比所以，我们最终的时间复杂度是：O（N） + N’*O（logK），（N为1000万，N’为300万）。

9. 有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M。返回频数最高的100个词

      方案：顺序读文件中，对于每个词x，取hash(x)%5000，然后按照该值存到5000个小文件（记为x0,x1,…x4999）中。这样每个文件大概是200k左右。如果其中的有的文件超过了1M大小，还可以按照类似的方法继续往下分，直到分解得到的小文件的大小都不超过1M。对每个小文件，统计每个文件中出现的词以及相应的频率（可以采用trie树/hash_map等），并取出出现频率最大的100个词（可以用含100个结点的最小堆），并把100个词及相应的频率存入文件，这样又得到了5000个文件。下一步就是把这5000个文件进行归并（类似与归并排序）的过程了。

10. 有10个文件，每个文件1G，每个文件的每一行存放的都是用户的query，每个文件的query都可能重复

     还是典型的TOP K算法，解决方案如下：
     方案1：顺序读取10个文件，按照hash(query)%10的结果将query写入到另外10个文件（记为）中。这样新生成的文件每个的大小大约也1G（假设hash函数是随机的）。找一台内存在2G左右的机器，依次对用hash_map(query, query_count)来统计每个query出现的次数。利用快速/堆/归并排序按照出现次数进行排序。将排序好的query和对应的query_cout输出到文件中。这样得到了10个排好序的文件。对这10个文件进行归并排序（内排序与外排序相结合）。
     方案2：一般query的总量是有限的，只是重复的次数比较多而已，可能对于所有的query，一次性就可以加入到内存了。这样，我们就可以采用trie树/hash_map等直接来统计每个query出现的次数，然后按出现次数做快速/堆/归并排序就可以了。
     方案3：与方案1类似，但在做完hash，分成多个文件后，可以交给多个文件来处理，采用分布式的架构来处理（比如MapReduce），最后再进行合并。

11. 给定a、b两个文件，各存放50亿个url，每个url各占64字节，内存限制是4G，让你找出a、b文件共同的url

      方案1：可以估计每个文件安的大小为5G×64=320G，远远大于内存限制的4G。所以不可能将其完全加载到内存中处理。考虑采取分而治之的方法。
遍历文件a，对每个url求取hash(url)%1000，然后根据所取得的值将url分别存储到1000个小文件（记为a0,a1,…,a999）中。这样每个小文件的大约为300M。遍历文件b，采取和a相同的方式将url分别存储到1000小文件（记为b0,b1,…,b999）。这样处理后，所有可能相同的url都在对应的小文件（a0vsb0,a1vsb1,…,a999vsb999）中，不对应的小文件不可能有相同的url。然后我们只要求出1000对小文件中相同的url即可。求每对小文件中相同的url时，可以把其中一个小文件的url存储到hash_set中。然后遍历另一个小文件的每个url，看其是否在刚才构建的hash_set中，如果是，那么就是共同的url，存到文件里面就可以了。
      方案2：如果允许有一定的错误率，可以使用Bloom filter，4G内存大概可以表示340亿bit。将其中一个文件中的url使用Bloom filter映射为这340亿bit，然后挨个读取另外一个文件的url，检查是否与Bloom filter，如果是，那么该url应该是共同的url（注意会有一定的错误率）。

12. 在2.5亿个整数中找出不重复的整数

      方案1：采用2-Bitmap（每个数分配2bit，00表示不存在，01表示出现一次，10表示多次，11无意义）进行，共需内存2^32 * 2 bit=1 GB内存，还可以接受。然后扫描这2.5亿个整数，查看Bitmap中相对应位，如果是00变01，01变10，10保持不变。所描完事后，查看bitmap，把对应位是01的整数输出即可。
      方案2：划分小文件的方法。然后在小文件中找出不重复的整数，并排序。然后再进行归并，注意去除重复的元素。

13. 给40亿个不重复的unsigned int的整数，没排过序的，然后再给一个数，如何快速判断这个数是否在那40亿个数中

      方案1：oo，申请512M的内存，一个bit位代表一个unsigned int值。读入40亿个数，设置相应的bit位，读入要查询的数，查看相应bit位是否为1，为1表示存在，为0表示不存在。
      方案2：因为2^32为40亿多，所以给定一个数可能在，也可能不在其中；这里我们把40亿个数中的每一个用32位的二进制来表示假设这40亿个数开始放在一个文件中。
      然后将这40亿个数分成两类:1.最高位为0，2.最高位为1。并将这两类分别写入到两个文件中，其中一个文件中数的个数=20亿（这相当于折半了）；与要查找的数的最高位比较并接着进入相应的文件再查找。再然后把这个文件为又分成两类:1.次最高位为0，2.次最高位为1。并将这两类分别写入到两个文件中，其中一个文件中数的个数=10亿（这相当于折半了）；与要查找的数的次最高位比较并接着进入相应的文件再查找。
      …….
      以此类推，就可以找到了,而且时间复杂度为O(logn)，方案2完。

14. 一个文本文件，大约有一万行，每行一个词，要求统计出其中最频繁出现的前10个词，请给出思想，给出时间复杂度分析

      用trie树统计每个词出现的次数，时间复杂度是O(n*le)（le表示单词的平准长度）。然后是找出出现最频繁的前10个词，可以用堆来实现，前面的题中已经讲到了，时间复杂度是O(n*lg10)。所以总的时间复杂度，是O(n*le)与O(n*lg10)中较大的哪一个。

15．100w个数中找出最大的100个数。

     方案1：用一个含100个元素的最小堆完成。复杂度为O(100w*lg100)。
     方案2：采用快速排序的思想，每次分割之后只考虑比轴大的一部分，知道比轴大的一部分在比100多的时候，采用传统排序算法排序，取前100个。复杂度为O(100w*100)。
     方案3：采用局部淘汰法。选取前100个元素，并排序，记为序列L。然后一次扫描剩余的元素x，与排好序的100个元素中最小的元素比，如果比这个最小的要大，那么把这个最小的元素删除，并把x利用插入排序的思想，插入到序列L中。依次循环，知道扫描了所有的元素。复杂度为O(100w*100)。

16．10台机器，每个机器2个cpu，2g内存，现在已知在10亿条记录的数据库里执行一次查询需要5秒，问用什么方法能让90%的查询能在100毫秒以内返回结果。

      将10亿条记录排序,然后分到10个机器中,分的时候是一个记录一个记录的轮流分,确保每个机器记录大小分布差不多,每一次查询时,同时提交给10台机器,同时查询,因为记录已排序,可以采用二分法查询.如果无法排序,只能顺序查询,那就要看记录本身的概率分布,否则不可能实现.
      10亿条数据均衡分配到10台电脑，每台电脑是1亿。PC数 1 2 3 4 5 6 7 8 9 10。2G内存 * 10 = 20G内存可以将90%的数据缓存到10台PC的内存中，剩下的数据缓存到硬件中的高速索引文件中。借此实现100毫秒响应系统。
      2台机器共4个CPU，也就是说并行操作的数量为4，也就是说，分页查询的基本单位为4条，假设分3级，10亿约=2的30次方（1073741824），按照1：1024安排级差
      第一级：全体数据
      第二级：262124组数据/共1048576个
      第三级：256组/1024个数据
      只在第一级和第二级放数据，而更高级只放关键字的索引，可大大提高效率