码迷，mamicode.com
首页 > 其他好文 > 详细

经典大数据面试题

时间：2018-06-10 00:33:52      阅读：192      评论：0      收藏：0      [点我收藏+]

标签：http   复杂   sdn   小文件   types   缓冲区   mod   能力   res   

什么是大数据？

大数据(big data,mega data)，或称巨量资料，指的是需要新处理模式才能具有更强的决策力、洞察力和流程优化能力的海量、高增长率和多样化的信息资产。 在维克托·迈尔-舍恩伯格及肯尼斯·库克耶编写的《大数据时代》中大数据指不用随机分析法(抽样调查)这样的捷径，而采用所有数据进行分析处理。大数据的4V特点:Volume(大量)、Velocity(高速)、Variety(多样)、Value(价值)。

1>给一个超过100G大小的log file,log中存着IP地址 ，设计算法找到出现次数最多的IP地址？
答：首先看到100G的日志文件，我们的第一反应肯定 是太大了，根本加载不到内存，更别说设计算法了， 那么怎么办呢？既然装不下，我们是不是可以将其切 分开来，一小部分一小部分轮流进入内存呢，答案当然是肯定的。

       在这里要记住一点：但凡是大数据的问题，都可通过 切分来解决它。
技术分享图片粗略算一下：如果我们将其分成1000个小文件，每个文件大概就是500M左右的样子，

现在计算机肯定轻轻 松松就能装下。

 技术分享图片那么，问题又来了，怎样才能保证相 同的IP被分到同一个文件中呢？
这里我想到的是哈希切分，使用相同的散列函数（如 BKDRHash）将所有IP地址转换为一个整数key，

再利用 index=key%1000就可将相同IP分到同一个文件。
技术分享图片依次将这1000个文件读入内存，出现次数最多的IP进行统计。
技术分享图片最后，在1000个出现次数最多的IP中找出最大的出现次数即为所求。

用到的散列函数：

[cpp] view plain copy
 
  1. template<class T>    
  2. size_t BKDRHash(const T *str)    
  3. {    
  4.     register size_t hash = 0;    
  5.     while (size_t ch = (size_t)*str++)    
  6.     {           
  7.         hash = hash * 131 + ch;   // 也可以乘以31、131、1313、13131、131313..            
  8.     }    
  9.     return hash;    
  10. }    


2>与上题条件相同，如何找到TOP K的IP？
答：这倒题说白了就是找前K个出现次数最多的IP，即 降序排列IP出现的次数。

技术分享图片与上题类似，我们用哈希切分对分割的第一个个小文件中出现最多的前K个IP建小堆，
技术分享图片然后读入第二个文件，将其出现次数最多的前K个IP与 堆中数据进行对比，
技术分享图片如果包含大于堆中的IP出现次数，则更新小堆，替换原堆中次数的出现少的数据
技术分享图片再读入第三个文件，以此类推……

技术分享图片直到1000个文件全部读完，堆中出现的K个IP即是出现 次数最多的前K个IP地址。


3>给定100亿个整数，设计算法找到只出现一次的整数 ？
答：看到此题目，我的第一反应就是估算其占用内存 的大小：100亿个int,一个int4个字节，100亿*4=400 亿字节
又因为42亿字节约等于4G，所以100亿个整数大概占用 的内存为40G，一次加载到内存显然是不太现实的。
反过来想，所有整数所能表示的范围为2^32,即16G， 故给出的数据有很多数据是重复的。

技术分享图片解法1：哈希切分
与第一题类似，用哈希切分将这些数据分到100个文件 中，每个文件大约400M，

将每一个文件依次加载到内存中，利用哈希表统计出 现一次的整数，

将100个文件中出现一次的整数汇总起来即为所求。
技术分享图片解法2：位图变形
我们知道，位图是利用每一位来表示一个整数是否存 在来节省空间，1表示存在，0表示不存在。
而上题对于所有整数而言，却有三种状态：不存在、 存在一次、存在多次。
故此，我们需要对传统位图进行扩展，用两位来表示 一个整数的状态：00表示不存在、

01表示存在一次， 10表示存在多次，11表示无效状态。
按照上述表示，两位表示一个整数状态，所有整数只 需要1G即可表示其存在与否。
技术分享图片解法3：
众所周知，一个整数占32位，那么我们可对每一位按 照0和1将其分为两个文件，

直到划分到最低位，如果 被分的文件中哪个文件只包含一个数据，那么，此数据即为只出现一次的整数。

如下图：

技术分享图片

 

4>给两个文件，分别有100亿个整数，我们只有1G内存 ，如何找到两个文件交集？
答：100亿*4字节 = 400亿字节 = 40G
技术分享图片解法1：普通查找
将其中的一个文件分为100个小文件，每一份占400M， 将每一小份轮流加到内存中，
与第二个文件中的数据进行对比，找到交集。此种算 法时间复杂度为O(N*N)。
技术分享图片解法2：哈希切分
对两个文件分别进行哈希切分，将其分为100个小文件 ，index=key%100（index为文件下标）
将两个文件中下标相同的小文件进行对比，找出其交 集。
将100个文件的交集汇总起来即为所给文件的文件交集 。此种算法时间复杂度为O(N)。
技术分享图片解法3：位图
我们知道，位图中的每一位就可代表一个整数的存在 与否，而16G的整数用位图512M即可表示，

将第一个文件中的整数映射到位图中去，拿第二个文件中的数字到第一个文件映射的位图中去 对比，

相同数字存在即为交集。此种算法时间复杂度 为O(N)。
注意：重复出现的数字交集中只会出现一次。

位图的简单模拟：

[cpp] view plain copy
 
  1. //位图：专门用来判断数据是否存在，不能统计数据出现的次数  
  2. class BitMap  
  3. {  
  4. public:  
  5.     BitMap(size_t N = 1024)//N代表需要判断的数据个数  
  6.     {  
  7.         _array.resize((N>>5) + 1);//相当于(N/32)+1,结果为需要开辟的字节个数  
  8.     }  
  9.   
  10.     void Set(size_t value)//将状态由无置为有，即0变为1  
  11.     {  
  12.         size_t index = value >> 5;//代表整数的下标，即第几个整数  
  13.         size_t num = value % 32;//代表第几位  
  14.           
  15.         _array[index] |= 1<<num;//将特定位置1  
  16.     }  
  17.   
  18.     void ReSet(size_t value)//将状态由有置为无，即1变为0  
  19.     {  
  20.         size_t index = value >> 5;//代表整数的下标，即第几个整数  
  21.         size_t num = value % 32;//代表第几位  
  22.   
  23.         _array[index] &= (~(1<<num));//将特定位置0  
  24.     }  
  25.   
  26.     bool Test(size_t value)  
  27.     {  
  28.         size_t index = value >> 5;//代表整数的下标，即第几个整数  
  29.         size_t num = value % 32;//代表第几位  
  30.   
  31.         return _array[index] & (1<<num);  
  32.     }  
  33. protected:  
  34.     std::vector<size_t> _array;//每个size_t可判断32个数是否存在  
  35. };  
  36.   
  37. void TestBitMap()  
  38. {  
  39.     BitMap bm((size_t)-1);  
  40.   
  41.     bm.Set(2);  
  42.     bm.Set(20);  
  43.     bm.Set(200);  
  44.     bm.Set(2000);  
  45.     bm.Set(20000);  
  46.     bm.Set(200000);  
  47.     bm.Set(2000000);  
  48.     bm.Set(20000000);  
  49.   
  50.     bm.ReSet(2);  
  51.     bm.ReSet(2000);  
  52.     bm.ReSet(2000000);  
  53.     bm.ReSet(20000000);  
  54.       
  55.     cout<<bm.Test(2)<<endl;  
  56.     cout<<bm.Test(20)<<endl;  
  57.     cout<<bm.Test(200)<<endl;  
  58.     cout<<bm.Test(2000)<<endl;  
  59.     cout<<bm.Test(20000)<<endl;  
  60.     cout<<bm.Test(200000)<<endl;  
  61.     cout<<bm.Test(2000000)<<endl;  
  62.     cout<<bm.Test(20000000)<<endl;  
  63. }  

 

运行结果：

技术分享图片



5>1个文件有100亿个int，1G内存，设计算法找到出现 次数不超过两次的所有整数？
答：类似题目3
技术分享图片解法1：哈希切分
与第一题类似，用哈希切分将这些数据分到100个文件 中，每个文件大约400M，
将每一个文件依次加载到内存中，利用哈希表统计出 现不超过两次的整数
将100个文件中出现不超过两次的整数汇总起来即为所求。
技术分享图片解法2：位图变形
我们知道，位图是利用每一位来表示一个整数是否存  在来节省空间，1表示存在，0表示不存在。
而上题对于所有整数而言，却有三种状态：不存在、  存在一次、存在多次。
故此，我们需要对传统位图进行扩展，用两位来表示  一个整数的状态：00表示不存在、

01表示存在一次，  10表示存在两次，11表示出现超过两次。
按照上述表示，两位表示一个整数状态，所有整数只需要1G即可表示其存在次数。


6>给两个文件，分别有100亿个query，我们只有1G内 存，如何找到两个文件交集？分别给出精确算法和近 似算法。
答：类似于第四题，
100亿*4字节 = 400亿字节 = 40G
技术分享图片精确算法：哈希切分
对两个文件分别进行哈希切分，使用相同的散列函数 （如 BKDRHash散列函数）将所有query

转换为一个整数key ，再利用 index=key%1000就可将相同query分到同一 个文件。（index为文件下标）

将两个文件中下标相同的小文件进行对比，找出其交 集。
将100个文件的交集汇总起来即为所给文件的文件交集 。此种算法时间复杂度为O(N)。
技术分享图片近似算法：布隆过滤器
首先使用相同的散列函数（如 BKDRHash散列函数）将所有 query转换为一个整数key，

又因为布隆过滤器中的每 一位就可代表一个整数的存在 与否，而16G的整数用 位图512M即可表示，
将第一个文件中的整数映射到位图中去，
拿第二个文件中的数字到第一个文件映射的位图中去对比，相同数字存在即为交集。
此种算法时间复杂度为O(N)。
注意：布隆过滤器判断不存在是确定的，而存存在在可能导致误判，所以称近似算法。

布隆过滤器的简单模拟：

各种不同的散列函数：

 

[cpp] view plain copy
 
  1. template<class T>    
  2. size_t BKDRHash(const T *str)    
  3. {    
  4.     register size_t hash = 0;    
  5.     while (size_t ch = (size_t)*str++)    
  6.     {           
  7.         hash = hash * 131 + ch;   // 也可以乘以31、131、1313、13131、131313..            
  8.     }    
  9.     return hash;    
  10. }    
  11.    
  12. template<class T>    
  13. size_t SDBMHash(const T *str)    
  14. {    
  15.     register size_t hash = 0;    
  16.     while (size_t ch = (size_t)*str++)    
  17.     {    
  18.         hash = 65599 * hash + ch;           
  19.         //hash = (size_t)ch + (hash << 6) + (hash << 16) - hash;    
  20.     }    
  21.     return hash;    
  22. }    
  23.     
  24. template<class T>    
  25. size_t RSHash(const T *str)    
  26. {    
  27.     register size_t hash = 0;    
  28.     size_t magic = 63689;       
  29.     while (size_t ch = (size_t)*str++)    
  30.     {    
  31.         hash = hash * magic + ch;    
  32.         magic *= 378551;    
  33.     }    
  34.     return hash;    
  35. }    
  36.   
  37. template<class T>    
  38. size_t APHash(const T *str)    
  39. {    
  40.     register size_t hash = 0;    
  41.     size_t ch;    
  42.     for (long i = 0; ch = (size_t)*str++; i++)    
  43.     {    
  44.         if ((i & 1) == 0)    
  45.         {    
  46.             hash ^= ((hash << 7) ^ ch ^ (hash >> 3));    
  47.         }    
  48.         else    
  49.         {    
  50.             hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));    
  51.         }    
  52.     }    
  53.     return hash;    
  54. }    
  55.     
  56. template<class T>    
  57. size_t JSHash(const T *str)    
  58. {    
  59.     if(!*str)        // 这是由本人添加，以保证空字符串返回哈希值0    
  60.         return 0;    
  61.     register size_t hash = 1315423911;    
  62.     while (size_t ch = (size_t)*str++)    
  63.     {    
  64.         hash ^= ((hash << 5) + ch + (hash >> 2));    
  65.     }    
  66.     return hash;    
  67. }    
  68. template<class T>    
  69. size_t DEKHash(const T* str)    
  70. {    
  71.     if(!*str)        // 这是由本人添加，以保证空字符串返回哈希值0    
  72.         return 0;    
  73.     register size_t hash = 1315423911;    
  74.     while (size_t ch = (size_t)*str++)    
  75.     {    
  76.         hash = ((hash << 5) ^ (hash >> 27)) ^ ch;    
  77.     }    
  78.     return hash;    
  79. }    
  80.     
  81. template<class T>    
  82. size_t FNVHash(const T* str)    
  83. {    
  84.     if(!*str)   // 这是由本人添加，以保证空字符串返回哈希值0    
  85.         return 0;    
  86.     register size_t hash = 2166136261;    
  87.     while (size_t ch = (size_t)*str++)    
  88.     {    
  89.         hash *= 16777619;    
  90.         hash ^= ch;    
  91.     }    
  92.     return hash;    
  93. }    
  94.     
  95. template<class T>    
  96. size_t DJBHash(const T *str)    
  97. {    
  98.     if(!*str)   // 这是由本人添加，以保证空字符串返回哈希值0    
  99.         return 0;    
  100.     register size_t hash = 5381;    
  101.     while (size_t ch = (size_t)*str++)    
  102.     {    
  103.         hash += (hash << 5) + ch;    
  104.     }    
  105.     return hash;    
  106. }    
  107.   
  108. template<class T>    
  109. size_t DJB2Hash(const T *str)    
  110. {    
  111.     if(!*str)   // 这是由本人添加，以保证空字符串返回哈希值0    
  112.         return 0;    
  113.     register size_t hash = 5381;    
  114.     while (size_t ch = (size_t)*str++)    
  115.     {    
  116.         hash = hash * 33 ^ ch;    
  117.     }    
  118.     return hash;    
  119. }    
  120.    
  121. template<class T>    
  122. size_t PJWHash(const T *str)    
  123. {    
  124.     static const size_t TotalBits       = sizeof(size_t) * 8;    
  125.     static const size_t ThreeQuarters   = (TotalBits  * 3) / 4;    
  126.     static const size_t OneEighth       = TotalBits / 8;    
  127.     static const size_t HighBits        = ((size_t)-1) << (TotalBits - OneEighth);        
  128.   
  129.     register size_t hash = 0;    
  130.     size_t magic = 0;       
  131.     while (size_t ch = (size_t)*str++)    
  132.     {    
  133.         hash = (hash << OneEighth) + ch;    
  134.         if ((magic = hash & HighBits) != 0)    
  135.         {    
  136.             hash = ((hash ^ (magic >> ThreeQuarters)) & (~HighBits));    
  137.         }    
  138.     }    
  139.     return hash;    
  140. }    
  141.     
  142. template<class T>    
  143. size_t ELFHash(const T *str)    
  144. {    
  145.     static const size_t TotalBits       = sizeof(size_t) * 8;    
  146.     static const size_t ThreeQuarters   = (TotalBits  * 3) / 4;    
  147.     static const size_t OneEighth       = TotalBits / 8;    
  148.     static const size_t HighBits        = ((size_t)-1) << (TotalBits - OneEighth);        
  149.     register size_t hash = 0;    
  150.     size_t magic = 0;    
  151.     while (size_t ch = (size_t)*str++)    
  152.     {    
  153.         hash = (hash << OneEighth) + ch;    
  154.         if ((magic = hash & HighBits) != 0)    
  155.         {    
  156.             hash ^= (magic >> ThreeQuarters);    
  157.             hash &= ~magic;    
  158.         }           
  159.     }    
  160.     return hash;    
  161. }    

 

布隆过滤器：

 

[cpp] view plain copy
 
  1. //布隆过滤器  
  2. struct __HashFunc1  
  3. {   
  4.     size_t operator()(const std::string& s)  
  5.     {  
  6.         return BKDRHash(s.c_str());  
  7.     }  
  8. };  
  9. struct __HashFunc2  
  10. {  
  11.     size_t operator()(const std::string& s)  
  12.     {  
  13.         return SDBMHash(s.c_str());  
  14.     }  
  15. };  
  16. struct __HashFunc3  
  17. {  
  18.     size_t operator()(const std::string& s)  
  19.     {  
  20.         return RSHash(s.c_str());  
  21.     }  
  22. };  
  23. struct __HashFunc4  
  24. {  
  25.     size_t operator()(const std::string& s)  
  26.     {  
  27.         return JSHash(s.c_str());  
  28.     }  
  29. };  
  30. struct __HashFunc5  
  31. {  
  32.     size_t operator()(const std::string& s)  
  33.     {  
  34.         return APHash(s.c_str());  
  35.     }  
  36. };  
  37.   
  38.   
  39. template<class K = string,  
  40. class HashFunc1 = __HashFunc1,  
  41. class HashFunc2 = __HashFunc2,  
  42. class HashFunc3 = __HashFunc3,  
  43. class HashFunc4 = __HashFunc4,  
  44. class HashFunc5 = __HashFunc5  
  45. >  
  46. class BloomFilter  
  47. {  
  48. public:  
  49.     BloomFilter(size_t N = 1024)  
  50.         :_bm(N * 10)  
  51.         ,_size(N * 10)  
  52.     {}  
  53.     void Set(const K& key)  
  54.     {  
  55.         size_t hash1 = HashFunc1()(key) % _size;  
  56.         size_t hash2 = HashFunc2()(key) % _size;  
  57.         size_t hash3 = HashFunc3()(key) % _size;  
  58.         size_t hash4 = HashFunc4()(key) % _size;  
  59.         size_t hash5 = HashFunc5()(key) % _size;  
  60.   
  61.         _bm.Set(hash1);  
  62.         _bm.Set(hash2);  
  63.         _bm.Set(hash3);  
  64.         _bm.Set(hash4);  
  65.         _bm.Set(hash5);  
  66.   
  67.         cout<<hash1<<":"<<hash2<<":"<<hash3<<":"<<hash4<<":"<<hash5<<endl;  
  68.     }  
  69.     //void ReSet(const K& key);//不支持  
  70.     bool Test(const K& key)  
  71.     {  
  72.         size_t hash1 = HashFunc1()(key) % _size;  
  73.         if (_bm.Test(hash1) == false)  
  74.             return false;  
  75.           
  76.         size_t hash2 = HashFunc2()(key) % _size;  
  77.         if (_bm.Test(hash2) == false)  
  78.             return false;  
  79.   
  80.         size_t hash3 = HashFunc3()(key) % _size;  
  81.         if (_bm.Test(hash3) == false)  
  82.             return false;  
  83.   
  84.         size_t hash4 = HashFunc4()(key) % _size;  
  85.         if (_bm.Test(hash4) == false)  
  86.             return false;  
  87.   
  88.         size_t hash5 = HashFunc5()(key) % _size;  
  89.         if (_bm.Test(hash5) == false)  
  90.             return false;  
  91.   
  92.         return true;  
  93.     }  
  94. protected:  
  95.     BitMap _bm;  
  96.     size_t _size;  
  97. };  


测试函数：

 

[cpp] view plain copy
 
  1. void TestBloomBitMap()  
  2. {  
  3.     BloomFilter<> bm(1024);  
  4.     bm.Set("http://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html");  
  5.     bm.Set("http://www.cnblogs.com/-clq/archive/2012/05/31/2528154.html");  
  6.     bm.Set("http://www.cnblogs.com/-clq/archive/2012/05/31/2528155.html");  
  7.     bm.Set("http://www.cnblogs.com/-clq/archive/2012/05/31/2528156.html");  
  8.     bm.Set("http://www.cnblogs.com/-clq/archive/2012/05/31/2528157.html");  
  9.   
  10.     cout<<bm.Test("http://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html")<<endl;  
  11.     cout<<bm.Test("http://www.cnblogs.com/-clq/archive/2012/05/31/2528158.html")<<endl;  
  12.     cout<<bm.Test("http://www.cnblogs.com/-clq/archive/2012/05/31/2528154.html")<<endl;  
  13. }  

 

运行结果：

技术分享图片


7>如何扩展BloomFilter使得它支持删除元素的操作？
答：因为一个布隆过滤器的key对应多个为位，冲突的 概率比较大，所以不支持删除，因为删除有可能影响 到其他元素。如果要对其元素进行删除，就不得不对 每一个位进行引用计数，同下题。

8>如何扩展BloomFilter使得它支持计数的操作？
答：我们都知道，位图非常的节省空间，但由于每一 位都要引入一个int,所以空间浪费还是比较严重的， 因此不得不放弃位图了，代码如下：

[cpp] view plain copy
 
  1. //带删除功能的布隆过滤器（引用计数）  
  2. template<class K = string,  
  3. class HashFunc1 = __HashFunc1,  
  4. class HashFunc2 = __HashFunc2,  
  5. class HashFunc3 = __HashFunc3,  
  6. class HashFunc4 = __HashFunc4,  
  7. class HashFunc5 = __HashFunc5  
  8. >  
  9. class RefBloomFilter  
  10. {  
  11. public:  
  12.     RefBloomFilter(size_t N = 1024)  
  13.         :_size(N * 10)  
  14.     {  
  15.         _refbm.resize(_size);  
  16.     }  
  17.     void Set(const K& key)  
  18.     {  
  19.         size_t hash1 = HashFunc1()(key) % _size;  
  20.         size_t hash2 = HashFunc2()(key) % _size;  
  21.         size_t hash3 = HashFunc3()(key) % _size;  
  22.         size_t hash4 = HashFunc4()(key) % _size;  
  23.         size_t hash5 = HashFunc5()(key) % _size;  
  24.   
  25.         _refbm[hash1]++;  
  26.         _refbm[hash2]++;  
  27.         _refbm[hash3]++;  
  28.         _refbm[hash4]++;  
  29.         _refbm[hash5]++;  
  30.   
  31.         cout<<hash1<<":"<<hash2<<":"<<hash3<<":"<<hash4<<":"<<hash5<<endl;  
  32.     }  
  33.     void ReSet(const K& key)  
  34.     {  
  35.         size_t hash1 = HashFunc1()(key) % _size;  
  36.         size_t hash2 = HashFunc2()(key) % _size;  
  37.         size_t hash3 = HashFunc3()(key) % _size;  
  38.         size_t hash4 = HashFunc4()(key) % _size;  
  39.         size_t hash5 = HashFunc5()(key) % _size;  
  40.   
  41.         _refbm[hash1]--;  
  42.         _refbm[hash2]--;  
  43.         _refbm[hash3]--;  
  44.         _refbm[hash4]--;  
  45.         _refbm[hash5]--;  
  46.     }  
  47.     bool Test(const K& key)  
  48.     {  
  49.         size_t hash1 = HashFunc1()(key) % _size;  
  50.         if (_refbm[hash1] <= 0)  
  51.             return false;  
  52.   
  53.         size_t hash2 = HashFunc2()(key) % _size;  
  54.         if (_refbm[hash2] <= 0)  
  55.             return false;  
  56.   
  57.         size_t hash3 = HashFunc3()(key) % _size;  
  58.         if (_refbm[hash3] <= 0)  
  59.             return false;  
  60.   
  61.         size_t hash4 = HashFunc4()(key) % _size;  
  62.         if (_refbm[hash4] <= 0)  
  63.             return false;  
  64.   
  65.         size_t hash5 = HashFunc5()(key) % _size;  
  66.         if (_refbm[hash5] <= 0)  
  67.             return false;  
  68.   
  69.         return true;  
  70.     }  
  71. protected:  
  72.     vector<size_t> _refbm;  
  73.     size_t _size;  
  74. }; 


9>给上千个文件，每一个文件大小为1K-100M,给n个单 词，设计算法对每个词找到所有包含它的文件，你只 有100K内存。
答：对上千个文件生成1000个布隆过滤器，并将1000 个布隆过滤器存入一个文件中，将内存分为两份，一 分用来读取布隆过滤器中的词，一块用来读取文件， 直到每个布隆过滤器读完为止。


技术分享图片用一个文件info 准备用来保存ｎ个词和包含其的文件信息。
技术分享图片 首先把ｎ个词分成ｘ份。对每一份用生成一个布 隆过滤器（因为对ｎ个词只生成一个布隆过滤器，内存可能不够用）。把生成的所有布隆过滤器存入外存 的一个文件Filter中。
技术分享图片将内存分为两块缓冲区，一块用于每次读入一个 布隆过滤器，一个用于读文件(读文件这个缓冲区使用 相当于有界生产者消费者问题模型来实现同步)，大文 件可以分为更小的文件，但需要存储大文件的标示信 息（如这个小文件是哪个大文件的）。
技术分享图片对读入的每一个单词用内存中的布隆过滤器来判 断是否包含这个值，如果不包含，从Filter文件中读 取下一个布隆过滤器到内存，直到包含或遍历完所有 布隆过滤器。如果包含,更新info 文件。直到处理完 所有数据。删除Filter文件。


10>有一个词典，包含N个英文单词，现在任意给一个 字符串，设计算法找出包含这个字符串的所有英文单 词。
答：对于这道题目，我们要用到一种特殊的数据结 构----字典树来解决它，所谓字典树，又称单词查找树（或Trie树），是一种哈希树的变种。
典型应用：用于统计、排序和保存大量的字符串，经 常被搜索引擎系统用于文本词频统计。
优点：利用字符串的公共前缀来减少查询时间，最大 限度地减少无谓的字符串比较，查询效率高于哈希表 。
基本性质：技术分享图片根节点不包含字符，除根节点外每个节点 都只包含一个字符；
                   技术分享图片从根节点到某一节点，路径上所有经过的字 符连接起来，为该节点对应的字符串；
                   技术分享图片  每个节点的所有子节点包含的字符都不相同 。
应用：串的快速检索、串排序、最长公共前缀

解：
用给出的N个单词建立一棵与上述字典树不同的字典树 ，用任意字符串与字典树中的每个节点中的单词进行 比较，在每层中查找与任意字符串首字母一样的，找到则遍历其下面的子树，找第二个字母，以此类推， 如果与任意字符串的字符全部相同，则算找到。

如下图：

技术分享图片

经典大数据面试题

标签：http   复杂   sdn   小文件   types   缓冲区   mod   能力   res   

原文地址：https://www.cnblogs.com/threetop/p/9161623.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！