标签：前缀 去重 key 应该 pre 原理 输入 等于 数学
简介全文行文是基于面试题的分析基础之上的，具体实践过程中，还是得具体情况具体分析，且各个场景下需要考虑的细节也远比本文所描述的任何一种解决方法复杂得多。
##何谓海量数据处理？
基于海量数据上的存储、处理、操作。
何谓海量，就是数据量太大，导致要么是无法在较短时间内迅速解决，要么是数据太大，导致无法一次性装入内存。
那解决办法呢?
至于单机及集群问题，通俗点来讲
处理海量数据，不外乎
本文第一部分、从set/map谈到hashtable/hash_map/hash_set，简要介绍下set/map/multiset/multimap，及hash_set/hash_map/hash_multiset/hash_multimap之区别(万丈高楼平地起，基础最重要)，而本文第二部分，则针对上述那6种方法模式结合对应的海量数据处理面试题分别具体阐述。
#从set/map到hashtable/hashmap/hashset
所以，综上什么样的结构决定其什么样的性质，因为set/map都是基于RB-tree之上，所以有自动排序功能，而hash_set/hash_map都是基于hashtable之上，所以不含有自动排序功能，至于加个前缀multi_无非就是允许键值重复而已。
Hash，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的函数。
Hash主要用于信息安全领域中加密算法，它把一些不同长度的信息转化成杂乱的128位的编码,这些编码值叫做Hash值. 也可以说，hash就是找到一种数据内容和数据存放地址之间的映射关系。
数组的特点是：寻址容易，插入和删除困难
链表的特点是：寻址困难，插入和删除容易。
那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法——拉链法，我们可以理解为“链表的数组”
左边很明显是个数组，数组的每个成员包括一个指针，指向一个链表的头，当然这个链表可能为空，也可能元素很多。我们根据元素的一些特征把元素分配到不同的链表中去，也是根据这些特征，找到正确的链表，再从链表中找出这个元素。
元素特征转变为数组下标的方法就是散列法
除法散列法
最直观的一种，上图使用的就是这种散列法，公式：index = value % 16
学过汇编的都知道，求模数其实是通过一个除法运算得到的，所以叫“除法散列法”。
index = (value * value) >> 28这几个“理想乘数”是如何得出来的呢？这跟一个法则有关，叫黄金分割法则，而描述黄金分割法则的最经典表达式无疑就是著名的斐波那契数列，如果你还有兴趣，就到网上查找一下“斐波那契数列”等关键字，我数学水平有限，不知道怎么描述清楚为什么，另外斐波那契数列的值居然和太阳系八大行星的轨道半径的比例出奇吻合，很神奇，对么？
对我们常见的32位整数而言，公式：
index = (value * 2654435769) >> 28
如果用这种斐波那契散列法的话，那我上面的图就变成这样了：
很明显，用斐波那契散列法调整之后要比原来的取模散列法好很多。
首先是这一天，并且是访问百度的日志中的IP取出来，逐个写入到一个大文件中。
注意到IP是32位的，最多有个2^32个IP。同样可以采用映射的方法，比如%1000，把整个大文件映射为1000个小文件，再找出每个小文中出现频率最大的IP（可以采用HashMap对那1000个文件中的所有IP进行频率统计，然后依次找出各个文件中频率最大的那个IP）及相应的频率。然后再在这1000个最大的IP中，找出那个频率最大的IP，即为所求。
还有几个问题
#堆
##概念
堆是一种特殊的二叉树,具备以下两种性质
这样就定义了一个最大堆
最小的一个元素就是数组第一个元素,那么二叉堆这种有序队列如何入队呢
假设要在这个二叉堆里入队一个单元，键值为2，那只需在数组末尾加入这个元素，然后尽可能把这个元素往上挪，直到挪不动，经过了这种复杂度为Ο(logn)的操作，二叉堆还是二叉堆。
那如何出队呢
出队一定是出数组的第一个元素，这么来第一个元素以前的位置就成了空位，我们需要把这个空位挪至叶子节点，然后把数组最后一个元素插入这个空位，把这个“空位”尽量往上挪。这种操作的复杂度也是Ο(logn)
###寻找热门查询，300万个查询字符串中统计最热门的10个查询
搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。假设目前有一千万个记录（这些查询串的重复度比较高，虽然总数是1千万，但如果除去重复后，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门），请你统计最热门的10个查询串，要求使用的内存不能超过1G。
解答：由上题，我们知道，数据大则划为小的，如一亿个IP求Top 10，可先%1000将IP分到1000个小文件中去，并保证一种IP只出现在一个文件中，再对每个小文件中的IP进行HashMap计数统计并按数量排序，最后归并或者最小堆依次处理每个小文件的Top10以得到最后的结果
但如果数据规模比较小，能一次性装入内存呢?比如这题，虽然有一千万个Query，但是由于重复度比较高，因此事实上只有300万的Query，每个Query 255字节，因此我们可以考虑把他们都放进内存中去（300万个字符串假设没有重复，都是最大长度，那么最多占用内存3M*1K/4=0.75G。所以可以将所有字符串都存放在内存中进行处理），而现在只是需要一个合适的数据结构，在这里，HashMap绝对是我们优先的选择。
所以我们放弃分而治之hash映射的步骤，直接上hash统计，然后排序。针对此类典型的TOP K问题，采取的对策往往是：HashMap + 堆
HashMap(Query，Value)，每次读取一个Query，如果该字串不在HashMap中，则加入该串，并将Value设1堆排序
借助堆这个数据结构，找出Top K，时间复杂度为N*logK,即借助堆结构，我们可以在log量级的时间内查找和调整。
因此，维护一个K(该题目中是10)大小的小根堆，然后遍历300万的Query，分别和根元素进行对比。
所以，我们最终的时间复杂度是O（N） + N‘ * O（logK），（N为1000万，N’为300万）。
O(k),调整堆O(logk)后，有k1>k2>...kmin(kmin设为小顶堆中最小元素)x>kmin，则更新堆(x入堆，用时logk)，否则不更新堆。这样下来，总费时O（k*logk+（n-k）*logk）=O（n*logk）logkhash(x)%5000,然后按照该值存到5000个小文件（记为x0,x1,...x4999）中。这样每个文件大概是200k。hash(query)%10将query写到另外10个文件(记为a0,a1,..a9)中HashMap(query, query_count)统计每个query频度count+1query和对应的query_cout输出到文件，就得到了10个排好序的文件
5G×64=320G，远远大于内存限制。所以不可能将其完全加载到内存中处理。考虑采取分而治之的方法
此即第一个秘技分而治之/hash映射 + hash统计 + 堆/快速/归并排序
再看最后4道题
###在海量数据中找出重复次数最多的
O(n*le)(le:单词平均长度），最终同样找出出现最频繁的前10个词（可用堆来实现），时间复杂度是O(n*lg10)。10. 1000万字符串，其中有些是重复的，需要把重复的全部去掉，保留没有重复的字符串。请怎么设计和实现？
方案1：首先根据用hash并求模，将文件分解为多个小文件，对于单个文件利用上题的方法求出每个文件件中10个最常出现的词。然后再进行归并处理，找出最终的10个最常出现的词。
###100w个数中找出最大的100个数
####方案1:局部淘汰法
一种算法设计思想。面对大量的数据我们无法处理时，可以将其分成一个个小任务，然后根据一定的策略来处理这些小任务，从而达到目的。
【扩展】 当有时候需要用一个小范围的数据来构造一个大数据，也是可以利用这种思想，相比之下不同的，只是其中的逆过程。
【问题实例】 1).2.5亿个整数中找出不重复的整数的个数，内存空间不足以容纳这2.5亿个整数。
有点像鸽巢原理，整数个数为2^32,也就是，我们可以将这2^32个数，划分为2^8个区域(比如用单个文件代表一个区域)，然后将数据分离到不同的区域，然后不同的区域在利用bitmap就可以直接解决了。也就是说只要有足够的磁盘空间，就可以很方便的解决。 当然这个题也可以用我们前面讲过的BitMap方法解决，正所谓条条大道通罗马~~~
2).5亿个int找它们的中位数。
这个例子比上面那个更明显。首先我们将int划分为2^16个区域，然后读取数据统计落到各个区域里的数的个数，之后我们根据统计结果就可以判断中位数落到那个区域，同时知道这个区域中的第几大数刚好是中位数。然后第二次扫描我们只统计落在这个区域中的那些数就可以了。
实际上，如果不是int是int64，我们可以经过3次这样的划分即可降低到可以接受的程度。即可以先将int64分成2^24个区域，然后确定区域的第几 大数，在将该区域分成2^20个子区域，然后确定是子区域的第几大数，然后子区域里的数的个数只有2^20，就可以直接利用direct addr table进行统计了。
3).现在有一个0-30000的随机数生成器。请根据这个随机数生成器，设计一个抽奖范围是0-350000×××中奖号码列表，其中要包含20000个中奖号码。
这个题刚好和上面两个思想相反，一个0到3万的随机数生成器要生成一个0到35万的随机数。那么我们完全可以将0-35万的区间分成35/3=12个区间，然后每个区间的长度都小于等于3万，这样我们就可以用题目给的随机数生成器来生成了，然后再加上该区间的基数。那么要每个区间生成多少个随机数呢？计算公式就是：区间长度随机数密度，在本题目中就是30000（20000/350000）。最后要注意一点，该题目是有隐含条件的：×××，这意味着你生成的随机数里面不能有重复，这也是我为什么用双层桶划分思想的另外一个原因。
其本质上还是分而治之思想,重在"分"
实际上，如果是long，我们可以经过3次这样的划分即可降低到可以接受的程度
即可以先将long分成2^24个区域，然后确定区域的第几大数，在将该区域分成2^20个子区域，然后确定是子区域的第几大数，然后子区域里的数的个数只有2^20，就可以直接利用direct addr table进行统计了。
###思路二
同样需要做两遍统计，如果数据存在硬盘上，就需要读取2次
方法同基排，开一个大小为65536的Int数组，第一遍读取，统计Int的高16位，也就是
第一遍统计之后，遍历数组累加，看中位数处于哪个区间
比如处于区间k，那么0~k-1内数字的数量sum应该<n/2（2.5亿）
而k+1 ~ 65535的计数和也<n/2
第二遍统计同上面方法，但这次只统计处于区间k的情况，也就是说(x / 65536) + 32768 = k。统计只统计低16位的情况。并且利用刚才统计的sum，比如sum = 2.49亿，那么现在就是要在低16位里面找100万个数(2.5亿-2.49亿)。这次计数之后，再统计一下，看中位数所处的区间，最后将高位和低位组合一下就是结果
#秘技三：Bloom filter/Bitmap
##Bloom filter
4G=2^32大概40亿*8大概340亿bitn=50亿，若按出错率0.01算需要大概650亿bit同时本题若允许有一定的错误率，可使用Bloom filter
将其中一个文件中的url使用Bloom filter映射为340亿bit，然后挨个读取另外一个文件的url，检查是否在Bloom filter，如果是，那么该url应该是共同的url（注意会有一定的错误率）
#BitMap
用一个bit位标记某个元素对应的Value， 而Key即是该元素
由于采用了bit为单位来存储数据，因此在存储空间方面，相对于 HashMap大大节省
看一个具体的例子，假设我们要对0-7内的5个元素(4,7,2,5,3)排序（假设这些元素没有重复）。
要表示8个数,我们就只需要8个Bit(1Byte),首先我们开辟1Byte的空间，将这些空间的所有Bit位都置为0
然后遍历这5个元素，首先第一个元素是4，那么就把4对应的位置为1,因为是从0开始的，所以要把第5位置1
然后遍历一遍bit区域，将是1的位的编号输出（2，3，4，5，7），就达到了排序的目的。下面的代码给出了一个BitMap的用法：排序
//定义每个Byte中有8个Bit位
#include ＜memory.h＞
#define BYTESIZE 8
void SetBit(char *p, int posi)
{
for(int i=0; i ＜ (posi/BYTESIZE); i++)
{
p++;
}
*p = *p|(0x01＜＜(posi%BYTESIZE));//将该Bit位赋值1
return;
}
void BitMapSortDemo()
{
//为了简单起见，我们不考虑负数
int num[] = {3,5,2,10,6,12,8,14,9};
//BufferLen这个值是根据待排序的数据中最大值确定的
//待排序中的最大值是14，因此只需要2个Bytes(16个Bit)
//就可以了。
const int BufferLen = 2;
char *pBuffer = new char[BufferLen];
//要将所有的Bit位置为0，否则结果不可预知。
memset(pBuffer,0,BufferLen);
for(int i=0;i＜9;i++)
{
//首先将相应Bit位上置为1
SetBit(pBuffer,num[i]);
}
//输出排序结果
for(int i=0;i＜BufferLen;i++)//每次处理一个字节(Byte)
{
for(int j=0;j＜BYTESIZE;j++)//处理该字节中的每个Bit位
{
//判断该位上是否是1，进行输出，这里的判断比较笨。
//首先得到该第j位的掩码（0x01＜＜j），将内存区中的
//位和此掩码作与操作。最后判断掩码是否和处理后的
//结果相同
if((*pBuffer&(0x01＜＜j)) == (0x01＜＜j))
{
printf("%d ",i*BYTESIZE + j);
}
}
pBuffer++;
}
}
int _tmain(int argc, _TCHAR* argv[])
{
BitMapSortDemo();
return 0;
}共需内存2^32 * 2 bit=1 GB,尚可接受
然后扫描这2.5亿个整数，查看BitMap中相应位，如果是00变01，01变10，10保持不变。
扫荡完毕后,查看BitMap,把对应位是01的整数输出即可
###方案2
也可采用与第1题类似的方法，进行划分小文件的方法。然后在小文件中找出不重复的整数，并排序。然后再进行归并，注意去除重复的元素
##40亿个不重复的非负int的整数，没排过序，然后再给一个数，如何快速判断这个数是否在那40亿个数当中
申请512M内存，一个bit位代表一个int非负值。读入40亿个数，设置相应的bit位，读入要查询的数，查看相应bit位是否为1，为1表示存在，为0表示不存在。
##Trie树
T0 = "it is what it is"
T1 = "what is it"
T2 = "it is a banana"我们就能得到下面的反向文件索引
? ? "a": ? ? ?{2}
????"banana": {2}
????"is": ? ? {0, 1, 2}
? ??"it": ? ? {0, 1, 2}
? ??"what": ? {0, 1}检索的条件"what","is"和"it"将对应集合的交集。
正向索引开发出来用来存储每个文档的单词的列表。正向索引的查询往往满足每个文档有序频繁的全文查询和每个单词在校验文档中的验证这样的查询。在正向索引中，文档占据了中心的位置，每个文档指向了一个它所包含的索引项的序列。也就是说文档指向了它包含的那些单词，而反向索引则是单词指向了包含它的文档，很容易看到这个反向的关系。
扩展：
问题实例：文档检索系统，查询那些文件包含了某单词，比如常见的学术论文的关键字搜索。
计算模型，简单的说就是将大批量的工作（数据）分解（MAP）执行，然后再将结果合并成最终结果（REDUCE）。这样做的好处是可以在任务被分解后，可以通过大量机器进行并行计算，减少整个操作的时间原理就是一个归并排序。
#非常大的文件，装不进内存。每行一个int类型数据，现在要你随机取100个数。
发现上述这道题，无论是以上任何一种模式/方法都不好做，那有什么好的别的方法呢？我们可以看看：操作系统内存分页系统设计(说白了，就是映射+建索引)。
Windows 2000使用基于分页机制的虚拟内存。每个进程有4GB的虚拟地址空间。基于分页机制，这4GB地址空间的一些部分被映射了物理内存，一些部分映射硬盘上的交换文 件，一些部分什么也没有映射。程序中使用的都是4GB地址空间中的虚拟地址。而访问物理内存，需要使用物理地址。 关于什么是物理地址和虚拟地址，请看：
? ? 物理内存分页，一个物理页的大小为4K字节，第0个物理页从物理地址 0x00000000 处开始。由于页的大小为4KB，就是0x1000字节，所以第1页从物理地址 0x00001000 处开始。第2页从物理地址 0x00002000 处开始。可以看到由于页的大小是4KB，所以只需要32bit的地址中高20bit来寻址物理页。?
? ? 返回上面我们的题目：非常大的文件，装不进内存。每行一个int类型数据，现在要你随机取100个数。针对此题，我们可以借鉴上述操作系统中内存分页的设计方法，做出如下解决方案：
OS中的方法，先生成4G的地址表，在把这个表划分为小的4M的小文件做个索引，二级索引。30位前十位表示第几个4M文件，后20位表示在这个4M文件的第几个，等等，基于key value来设计存储，用key来建索引。
标签：前缀 去重 key 应该 pre 原理 输入 等于 数学
原文地址：http://blog.51cto.com/13601128/2337471
