面试指导：海量数据处理面试题攻略

快来打我* 2022-05-23 05:51 347阅读 0赞

*  海量数据
 *  第一部分：从set/map谈到hashtable/hash\_map/hash\_set
    
     *  set/map/multiset/multimap
     *  hash\_set/hash\_map/hash\_multiset/hash\_multimap
 *  第二部分：处理海量数据问题的六把钥匙
    
     *  钥匙一：分而治之/Hash映射 + Hash统计 + 堆/快速/归并排序
        
         *  1、海量日志数据，提取出某日访问百度次数最多的那个IP
         *  2、寻找热门查询，300万个查询字符串中统计最热门的10个查询
         *  3、有一个1G大小的文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M，返回频数最高的100个词。
         *  4、海量数据分布在100台计算机中，想办法高效统计出这批数据的TOP 10。
         *  5、有10个文件，每个文件1G，每个文件的每一行存放的都是用户的查询串，每个文件的查询串都有可能重复。现在，要求你按照查询串的频度进行排序。
         *  6、给定a和b两个文件，各存放50亿个URL，每个URL各占64字节，内存限制是4G，那么，如何从a和b文件中找出共同的URL？
         *  7、如何在海量数据中找出重复次数最多的那个数据？
         *  8、对于上千万或上亿数据（有重复） ，统计其中出现次数最多的前N个数据。
         *  9、一个文本文件，大约有一万行，每行一个词，要求统计出其中频度最高的前10个词，请给出思想以及时间复杂度分析。
         *  10、1000万字符串，其中有些是重复的，现需要把重复的全部去掉，保留没有重复的字符串。请问怎么设计和实现？
         *  11、对于一个文本文件，其行数为10亿级别，无法一次读入内存，请找出前10个经常出现的词。
         *  12、从100万个数中找出最大的100个数。
     *  钥匙二：多层划分
        
         *  13、从2.5亿个整数找出不重复的整数的个数，内存空间不足以容纳这2.5亿个整数。
         *  14、在5亿个int整数中找出它们的中位数。
     *  钥匙三：布隆滤波器/位图
        
         *  布隆滤波器
         *  位图
         *  15、给你a和b两个文件，各存放50亿条URL，每条URL占用64字节，内存限制是4G，请找出a、b文件共同的URL。
         *  16、在2.5亿个整数中找出不重复的整数，注，内存不足以容纳这2.5亿个整数。
         *  17、给40亿个不重复的unsigned int的整数，没排过序的，然后再给一个数，如何快速判断这个数是否在那40亿个数当中？
     *  钥匙四：Trie树/数据库/倒排索引
        
         *  Trie树
         *  数据库索引
         *  倒排索引(Inverted index)
     *  钥匙五：外排序
     *  钥匙六：分布式处理之MapReduce
 *  后记

# 海量数据 #

所谓海量数据处理，无非就是基于海量数据上的存储、处理和操作。

何谓海量？就是数据量太大，所以导致要么是无法在短时间内迅速解决，要么是数据量太大，导致无法一次性装载入内存。

那解决方法呢？

针对时间，我们可以采用巧妙的算法搭配合适的数据结构，例如Bloom Filter、HashMap、BitMap、堆、数据库或倒排索引、Trie树；针对空间，无非就是一个办法，即大而化小，各个击破，缩小规模，逐个解决。

至于所谓的单机和集群问题，通俗点来讲，单机就是处理装载数据的机器有限（只要考虑CPU、内存、硬盘的数据交互），而集群中则有多台机器，适合分布式处理和并行计算（更多考虑节点和节点间的数据交互）。

处理海量数据问题的方法，无非就是：

*  分而治之/Hash映射+Hash统计+堆/快速/归并排序
 *  双层桶划分
 *  布隆滤波器/位图
 *  Trie字典树/数据库/倒排索引
 *  外排序
 *  分布式处理之Hadoop及MapReduce

下面，我们将内容安排如下：

在本文的第一部分，我们将从set/map谈到hashtable/hash\_map/hash\_set，简要介绍下set/map/multimap/multiset，以及hash\_set/hash\_map/hash\_multiset/hash\_multimap的区别。在本文的第二部分，则针对上述那6种方法模式结合对应的海量数据处理面试题进行分别具体阐述。

# 第一部分：从set/map谈到hashtable/hash\_map/hash\_set #

一般来说，STL容器分为两种：

*  序列式容器（vector/list/deque/stack/queue/heap）
 *  关联式容器（set/map）

关联式容器分为set（集合）和map（映射表）两大类，以及这两大类的衍生体multiset（多键集合）和multimap（多键映射表），这些容器均以RB-Tree红黑树完成。关联式容器还包括第三类关联式容器，如hashtable以及以hashtable为底层机制完成的hash\_set/hash\_map/hash\_multimap/hash\_multiset。

也就是说，set/map/multiset/multimap都内含一个RB-Tree，而hashset/hashmap/hash\_multiset/hash\_multimap都内含一个hashtable。

所谓关联式容器，类似于关联式数据库，每笔数据或每个元素都有一个键（key）和一个值（value），即所谓的key-value键值对。当元素被插入到关联式容器时，容器内部结构便依照其键大小，以某种特定规则将这个元素放置于适当位置。

## set/map/multiset/multimap ##

set，同map一样，所有元素都会根据元素的键自动被排序。因为set/map两者的所有各种操作，都只是转而调用RB-tree的操作行为，不过，值得注意的是，两者都不允许两个元素有相同的键值。

set的元素不像map那样可以同时拥有值value和键key，set元素的键就是值，值就是键，而map的所有元素都是pair，同时拥有值value和键key，pair的第一个元素被视为键，第二个元素被视为值。

至于multiset/multimap，它们的特性及用法和set/map完全相同，唯一的差别就在于它们允许键重复，即所有的插入操作基于RB-tree的insert\_equal()而非insert\_unique()。

## hash\_set/hash\_map/hash\_multiset/hash\_multimap ##

hash\_set/hash\_map，两者的一切操作都是基于hashtable之上。不同的是，hash\_set同set一样，同时拥有值和键，且值就是键，键就是值，而hash\_map同map一样，每一个元素同时拥有一个值value和一个键key，所以其使用方式，和上面的map基本相同。但由于hash\_set/hash\_map都是基于hashtable之上，所以不具备自动排序功能。为什么呢？因为hashtable没有自动排序功能。

至于hash\_multiset/hash\_multimap的特性与上面的multiset/multimap完全相同，唯一的差别就是它们hash\_multiset/hash\_multimap的底层实现机制是hashtable（而multiset/multimap，上面说了，底层实现机制是RB-tree），所以它们的元素都不会被自动排序，不过也都允许键值重复。

所以，综上，说白了，什么样的结构决定其什么样的性质，因为set/map/multiset/multimap都是基于RB-tree之上，所以有自动排序功能，而hash\_set/hash\_map/hash\_multiset/hash\_multimap都是基于hashtable之上，所以不含有自动排序功能，至于加个前缀multi\_无非就是允许键值重复而已。

# 第二部分：处理海量数据问题的六把钥匙 #

## 钥匙一：分而治之/Hash映射 + Hash统计 + 堆/快速/归并排序 ##

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

既然是海量数据处理，那么可想而知，给我们的数据那一定是海量的。针对这个数据的海量，我们应该如何着手呢？

是的，无非就是**分而治之/Hash映射 + Hash统计 +堆/快速/归并排序**，说白了，就是**先映射，后统计，最后排序**。

*  Step1：分而治之/Hash映射

针对数据太大，内存受限，采用将大文件取模映射成小文件，即16字方针：大而化小，各个击破，缩小规模，逐个解决。

*  Step2：Hash统计

当大文件转化成为小文件，那么我们便可以采用常规的hash\_map(ip, value)来进行频率统计。

*  Step3：堆/快速/归并排序

统计完了之后，便可以进行排序（可采用堆排序），得到访问次数最多的IP地址。

具体而论，过程如下：

首先从这一天访问百度的日志的IP提取出来，逐个写入到一个大文件中。可以采用映射的方法，比如%1000，把整个大文件映射为1000个小文件，然后再找出每个小文件中出现频率最大的IP（可以采用hash\_map对那1000个文件中的所有IP进行频率统计，然后依次找出各个文件中频率最大的那个IP）以及相应的频率，然后再在这1000个最大的IP中，找出频率最大的IP，即为所求。

注意几个问题：

1.  Hash取模是一种等价映射，不会存在同一个元素分散到不同小文件中的情况，即这里采用的mod1000算法，那么相同的IP在hash取模后，只可能落在同一文件中，不可能被分散的。因为如果两个IP相等，那么经过Hash(IP)之后的哈希值是相同的，将此哈希值取模，必定仍然相等。
2.  那到底什么是hash映射呢？简单来说，就是为了便于计算机在有限的内存中处理大数据，从而通过一种映射散列的方式让数据均匀分布在对应的内存位置（如大数据通过取余的方式映射成小树存放在内存中，或大文件映射成多个小文件），而这个映射散列方式便是我们通常所说的hash函数，设计的好的hash函数能让数据均匀分布而减少冲突。尽管数据映射到了另外一些不同的位置，但数据还是原来的数据，只是代替和表示这些原始数据的形式发生了变化而已。

### 2、寻找热门查询，300万个查询字符串中统计最热门的10个查询 ###

搜索引擎会通过日志文件把用户每次检索使用的所有查询串都记录下来，每个查询串的长度为1-255字节。假设目前有1000万个记录（虽然总数1000万，但是去重后，不超过300万。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门），请你统计出最热门的10个查询串，要求使用的内存不能超过1G。

解决方案：

虽然有1000万个查询串，但是由于重复度比较高，事实上只有300万的查询串，每个查询串为255字节，总共3M \* 255B = 0.75G，因此我们可以考虑把它们都放进内存中去，而现在只是需要一个合适的数据结构，在这里，我们优先选择Hashtable。

因此，我们放弃分而治之/Hash映射的步骤，直接进入Hash统计，然后再排序。故，针对此类典型的TOP\_K问题，采取的策略往往是**HashMap + 堆排序**。具体如下所示：

*  hash\_map统计：对海量数据进行数据预处理。具体为维护一个键为查询串，值为查询串出现次数的hashtable，即hash\_map(query, count)，每次读取一个查询串，如果该查询串不在table中，则插入(query, 1)；如果该查询串在table中，则将其计数加一。最终，我们在O(N)的时间复杂度内用哈希表完成了数据统计。
 *  堆排序：借助堆这个数据结构，找出TOP K，时间复杂度为`N*logK`。具体为维护一个K大小的小根堆，然后遍历300万的查询串，分别和根元素进行对比。所以，我们最终的时间复杂度为：`O(N) + N’ * logK`（N为1000万，N‘为300万）。

当然，也可以使用trie树来实现。

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

由上面的两个例题，分而治之+Hash统计+堆/快速排序这个套路，我们已经开始有了屡试不爽的感觉。

对于此题，又是文件很大，又是内存受限，怎么办？无非还是：

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

### 4、海量数据分布在100台计算机中，想办法高效统计出这批数据的TOP 10。 ###

**情况一**：如果每个数据元素只出现一次，而且只出现在某一台机器中，那么可以采取以下步骤统计出现次数TOP 10的数据元素：

*  堆排序：在每台机器上求出TOP 10，可以采用包含10个元素的堆来完成TOP 10搜索过程（TOP10小，用最大堆，TOP10大，用最小堆。比如求TOP10大，我们首先取前10个元素调整成最小堆，如果发现，然后扫描后面的数据，并与堆顶元素比较，如果比堆顶元素大，那么用该元素替换堆顶，然后再调整为最小堆，最后堆中的元素就是TOP10大）。
 *  求出每台机器上的TOP 10后，然后把这100台机器上的TOP 10组合起来，共1000个数据，然后再利用上面类似的方法求出TOP 10即可。

**情况二**：如果同一个元素重复出现在不同的机器中，比如2台机器求TOP 2，第一台：50/50/49/49/0/0，第二台：0/0/49/49/50/50，此时有两种方法可以尝试求解出现次数的TOP 2。

*  遍历一遍所有数据，重新Hash取模，使得同一个元素只出现在一台机器上，然后采用上面所说的方法，统计每台机器中每个元素的出现次数，找出TOP 10，继而组合100台机器上的TOP 10，找出最终的TOP 10。
 *  暴力求解，直接统计每台机器中各个元素的出现次数，然后把同一个元素在不同机器中的出现次数相加，最终从所有数据中找出TOP 10。

### 5、有10个文件，每个文件1G，每个文件的每一行存放的都是用户的查询串，每个文件的查询串都有可能重复。现在，要求你按照查询串的频度进行排序。 ###

方案一：

*  Hash映射：顺序读取10个文件，按照hash(query)%10的结果将query写入到另外10个文件（记为a0, a1, …, a9）中，这样新生成的每个文件的大小大约也1G（假设hash函数是随机的）。
 *  Hash统计：用一台内存为2G左右的机器，依次对用hash\_map(query, query\_count)来统计每个query出现的次数。其中，hash\_map(query, query\_count)是用来统计每个query的出现次数，而不是存储它们的值，出现一次，则count ++。
 *  堆/快速/归并排序：利用快速/堆/归并排序按照出现的次数进行排序，将排序好的query和对应的query\_count输出到文件中，这样就得到10个排好序的文件（记为b0, b1, …, b10）。最后，对这10个文件进行归并排序（内排序与外排序相结合）。

方案二：

一般query的总量是有限的，只是重复的次数比较多而已，可能对于所有的query，一次性就可以加入到内存了。这样，我们就可以采用trie树/hash\_map等直接来统计每个query出现的次数，然后按出现次数做快速/堆/归并排序就可以了。

方案三：

与方案一类似，但是在做完hash，并分成多个文件后，可以交给多个文件来处理，采用分布式的架构来处理（比如MapReduce），最后再进行合并。

### 6、给定a和b两个文件，各存放50亿个URL，每个URL各占64字节，内存限制是4G，那么，如何从a和b文件中找出共同的URL？ ###

我们可以估计每个文件的大小为5G\*64=320G，远远大于内存限制的4G，因此不可能将其完全加载到内存中处理，我们可以考虑采取分而治之的方法。

具体过程如下：

*  分而治之/Hash映射：遍历文件a，对每个url求取hash(url)%1000，然后根据所取得的值将url分别存储到1000个小文件（记为a0, a1, …, a999）中，这样每个小文件的大小约300M。然后，遍历文件b，采取和a相同的方式将url分别存储到1000个小文件（记为b0, b1, …, b999）中。这样处理后，所有可能相同的url都在对应的小文件（a0 vs b0, a1 vs b1, …, a999 vs b999）中，不对应的小文件不可能有相同的URL，然后我们只要求出1000对小文件中相同的url即可。
 *  Hash统计：求每对小文件中相同的url时，可以把其中一个小文件的url存储到hash\_set中，然后遍历另一个小文件的每个url，看其是否在刚才构建的hash\_set中，如果是，那么就是共同的url，存到文件里面就可以了。

### 7、如何在海量数据中找出重复次数最多的那个数据？ ###

具体方案如下：

首先利用Hash映射算法将海量数据求模映射到不同的小文件中，然后分别求出每个小文件中重复次数最多的一个，并记录重复次数。最后，找出前面求出的数据中重复次数最多的一个即为所求。

### 8、对于上千万或上亿数据（有重复） ，统计其中出现次数最多的前N个数据。 ###

具体方案如下：

对于上千万或者上亿数据，如果机器的内存能够存下，则直接使用内存处理；如果机器内存存不下，则可以使用Hash映射将数据映射到不同的文件中。然后使用hash\_map/搜索二叉树/红黑树等数据结构进行数据的次数统计，然后使用堆排序取出前N个出现次数最多的数据即可。

### 9、一个文本文件，大约有一万行，每行一个词，要求统计出其中频度最高的前10个词，请给出思想以及时间复杂度分析。 ###

方案一：

如果文件比较大，无法一次性读入内存，可以采用hash取模的方法，将大文件分解为多个小文件，对于单个小文件利用hash\_map统计出每个小文件中10个最常出现的词，然后再进行归并处理，找出最终的10个最常出现的词。

方案二：

通过Hash取模将大文件分解为多个小文件后，除了可以用hash\_map统计出每个小文件中10个最常出现的词，也可以用trie树统计每个词出现的次数，时间复杂度是O(n\*le)（le表示单词的平准长度），最终同样找出出现最频繁的前10个词（可用堆来实现），时间复杂度是O(n\*lg10)。

### 10、1000万字符串，其中有些是重复的，现需要把重复的全部去掉，保留没有重复的字符串。请问怎么设计和实现？ ###

方案一：

这题用trie树比较合适，hash\_map也行。

方案二：

1000w的数据规模插入操作完全不现实，以前试过在STL下100w元素插入set中已经慢得不能忍受，觉得基于hash的实现不会比红黑树好太多，使用vector+sort+unique都要可行许多，建议还是先hash成小文件分开处理再综合。

方案三：

考虑使用布尔滤波器和位图实现。

### 11、对于一个文本文件，其行数为10亿级别，无法一次读入内存，请找出前10个经常出现的词。 ###

具体方案如下：

首先根据Hash求模，将文件分解为多个小文件。然后对于多个小文件，利用上面的方法求出每个文件中10个最常出现的词，然后再进行归并处理，找出最终的10个最常出现的词。

### 12、从100万个数中找出最大的100个数。 ###

方案一：

采用局部淘汰法。选取前100个元素，并排序，记为序列L。然后一次扫描剩余的元素x，与排好序的100个元素中最小的元素比，如果比这个最小的要大，那么把这个最小的元素删除，并把x利用插入排序的思想，插入到序列L中。依次循环，直到扫描了所有的元素。其时间复杂度为O(100w\*100)。

方案二：

采用快速排序的思想，每次分割之后只考虑比轴大的一部分，直到比轴大的一部分在比100多的时候，采用传统排序算法排序，取前100个。其时间复杂度为O(100w\*100)。

方案三：

在前面的题中，我们已经提到了，用一个含100个元素的最小堆完成。其时间复杂度为O(100w\*lg100)。

## 钥匙二：多层划分 ##

多层划分——其实本质上还是分而治之的思想，重在分的技巧上。

适用范围：第k大，中位数，不重复或重复的数字。

基本原理及要点：因为元素范围很大，不能利用直接寻址表，所以通过多次划分，逐步确定范围，然后最后在一个可以接受的范围内进行。

### 13、从2.5亿个整数找出不重复的整数的个数，内存空间不足以容纳这2.5亿个整数。 ###

方案一：

使用Hash映射的方法，将2.5亿个整数拆分成多个小文件，然后使用hash\_map统计取出每个小文件中不重复的数，最后合并即可。

方案二：

采用2-bitmap（每个数分配2个bit，00表示不存在，01表示出现一次，10表示出现多次，11无意义）进行统计，共需内存2^32 \* 2bit = 1GB内存，还可以接受。然后扫描这2.5亿个整数，查看2-bitmap中相应位对，如果是00则置为01，如果是01则置为10，其余保持不变。扫描完毕后，查看2-bitmap，将对应位对是01的整数输出即可。

### 14、在5亿个int整数中找出它们的中位数。 ###

将int数域划分为2^16个区域，然后遍历读取数据，统计落到各个区域中的数的个数，然后根据统计结果，可以判断中位数落在哪个区域。同时，我们可以知道这个区域中第几大数是中位数，第二次扫描时，我们只需统计落在该区域内的那些数就可以了。

## 钥匙三：布隆滤波器/位图 ##

### 布隆滤波器 ###

参见：布隆滤波器一文

适用范围：可以用来实现数据字典，进行数据的判重，或者集合求交集。

基本原理及要点：对于原理来说很简单，`位数组+k个独立hash函数`。将hash函数对应的值的位数组置1，查找时如果发现所有hash函数对应位都是1说明存在，很明显这个过程并不保证查找的结果是100%正确的。同时也不支持删除一个已经插入的关键字，因为该关键字对应的位会牵动到其他的关键字。所以一个简单的改进就是Counting Bloom filter，用一个counter数组代替位数组，就可以支持删除了。

### 位图 ###

参见：位图一文

基本原理及要点：使用bit数组来表示某些元素是否存在，比如8位电话号码

扩展：Bloom filter可以看做是对bit-map的扩展

### 15、给你a和b两个文件，各存放50亿条URL，每条URL占用64字节，内存限制是4G，请找出a、b文件共同的URL。 ###

根据这个问题我们来计算下内存的占用，4G=2^32大概是40亿\*8大概是340亿，n=50亿，如果按出错率0.01算需要的大概是650亿个bit。现在可用的是340亿，相差并不多，这样可能会使出错率上升些。另外如果这些urlip是一一对应的，就可以转换成ip，则大大简单了。

同时，上文的第6题：给定a、b两个文件，各存放50亿个url，每个url各占64字节，内存限制是4G，让你找出a、b文件共同的url？如果允许有一定的错误率，可以使用Bloom filter，4G内存大概可以表示340亿bit。将其中一个文件中的url使用Bloom filter映射为这340亿bit，然后挨个读取另外一个文件的url，检查是否与Bloom filter，如果是，那么该url应该是共同的url（注意会有一定的错误率）。

### 16、在2.5亿个整数中找出不重复的整数，注，内存不足以容纳这2.5亿个整数。 ###

参加题13，理解bitmap的使用方法。

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

方案：用位图/Bitmap的方法，申请512M的内存，一个bit位代表一个unsigned int值。读入40亿个数，设置相应的bit位，读入要查询的数，查看相应bit位是否为1，为1表示存在，为0表示不存在。

## 钥匙四：Trie树/数据库/倒排索引 ##

### Trie树 ###

适用范围：数据量大，重复多，但是数据种类小可以放入内存

基本原理及要点：实现方式，节点孩子的表示方式

扩展：压缩实现

问题实例：

*  寻找热门查询：查询串的重复度比较高，虽然总数是1千万，但如果除去重复后，不超过3百万个，每个不超过255字节。
 *  有10个文件，每个文件1G，每个文件的每一行都存放的是用户的query，每个文件的query都可能重复。要你按照query的频度排序。1000万字符串，其中有些是相同的(重复),需要把重复的全部去掉，保留没有重复的字符串。请问怎么设计和实现？
 *  一个文本文件，大约有一万行，每行一个词，要求统计出其中最频繁出现的前10个词。其解决方法是：用trie树统计每个词出现的次数，时间复杂度是O(n\*le)（le表示单词的平准长度），然后是找出出现最频繁的前10个词。

### 数据库索引 ###

适用范围：大数据量的增删改查

基本原理及要点：利用数据的设计实现方法，对海量数据的增删改查进行处理。

关于数据库索引及其优化，更多可参见此文：[http://www.cnblogs.com/pkuoliver/archive/2011/08/17/mass-data-topic-7-index-and-optimize.html][http_www.cnblogs.com_pkuoliver_archive_2011_08_17_mass-data-topic-7-index-and-optimize.html]

关于MySQL索引背后的数据结构及算法原理，这里还有一篇很好的文章：[http://blog.codinglabs.org/articles/theory-of-mysql-index.html][http_blog.codinglabs.org_articles_theory-of-mysql-index.html]

关于B 树、B+ 树、B\* 树及R 树，本blog内有篇绝佳文章：[http://blog.csdn.net/v\_JULY\_v/article/details/6530142][http_blog.csdn.net_v_JULY_v_article_details_6530142]

### 倒排索引(Inverted index) ###

适用范围：搜索引擎，关键字查询

基本原理及要点：为何叫倒排索引？一种索引方法，被用来存储在全文搜索下某个单词在一个文档或者一组文档中的存储位置的映射

以英文为例，下面是要被索引的文本：

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”将对应集合的交集。

正向索引开发出来用来存储每个文档的单词的列表。正向索引的查询往往满足每个文档有序频繁的全文查询和每个单词在校验文档中的验证这样的查询。在正向索引中，文档占据了中心的位置，每个文档指向了一个它所包含的索引项的序列。也就是说文档指向了它包含的那些单词，而反向索引则是单词指向了包含它的文档，很容易看到这个反向的关系。

## 钥匙五：外排序 ##

适用范围：大数据的排序，去重

基本原理及要点：外排序的归并方法，置换选择败者树原理，最优归并树

问题实例：有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16个字节，内存限制大小是1M。返回频数最高的100个词。这个数据具有很明显的特点，词的大小为16个字节，但是内存只有1M做hash明显不够，所以可以用来排序。内存可以当输入缓冲区使用。

## 钥匙六：分布式处理之MapReduce ##

MapReduce是一种计算模型，简单的说就是将大批量的工作（数据）分解（MAP）执行，然后再将结果合并成最终结果（REDUCE）。这样做的好处是可以在任务被分解后，可以通过大量机器进行并行计算，减少整个操作的时间。但如果你要我再通俗点介绍，那么，说白了，Mapreduce的原理就是一个归并排序。

适用范围：数据量大，但是数据种类小可以放入内存

基本原理及要点：将数据交给不同的机器去处理，数据划分，结果归约。

问题实例：

*  海量数据分布在100台电脑中，想个办法高效统计出这批数据的TOP10。
 *  一共有N个机器，每个机器上有N个数。每个机器最多存O(N)个数并对它们操作。如何找到N^2个数的中数(median)？

# 后记 #

经过上面这么多海量数据处理面试题的轰炸，我们依然可以看出这类问题是有一定的解决方案/模式的，所以，不必将其神化。

[http_www.cnblogs.com_pkuoliver_archive_2011_08_17_mass-data-topic-7-index-and-optimize.html]: http://www.cnblogs.com/pkuoliver/archive/2011/08/17/mass-data-topic-7-index-and-optimize.html
[http_blog.codinglabs.org_articles_theory-of-mysql-index.html]: http://blog.codinglabs.org/articles/theory-of-mysql-index.html
[http_blog.csdn.net_v_JULY_v_article_details_6530142]: http://blog.csdn.net/v_JULY_v/article/details/6530142