经典大数据面试题

什么是大数据？

大数据(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. void Set(size_t value)//将状态由无置为有，即0变为1
  10. {
  11. size_t index = value >> 5;//代表整数的下标，即第几个整数
  12. size_t num = value % 32;//代表第几位
  13. _array[index] |= 1<<num;//将特定位置1
  14. }
  15. void ReSet(size_t value)//将状态由有置为无，即1变为0
  16. {
  17. size_t index = value >> 5;//代表整数的下标，即第几个整数
  18. size_t num = value % 32;//代表第几位
  19. _array[index] &= (~(1<<num));//将特定位置0
  20. }
  21. bool Test(size_t value)
  22. {
  23. size_t index = value >> 5;//代表整数的下标，即第几个整数
  24. size_t num = value % 32;//代表第几位
  25. return _array[index] & (1<<num);
  26. }
  27. protected:
  28. std::vector<size_t> _array;//每个size_t可判断32个数是否存在
  29. };
  30. void TestBitMap()
  31. {
  32. BitMap bm((size_t)-1);
  33. bm.Set(2);
  34. bm.Set(20);
  35. bm.Set(200);
  36. bm.Set(2000);
  37. bm.Set(20000);
  38. bm.Set(200000);
  39. bm.Set(2000000);
  40. bm.Set(20000000);
  41. bm.ReSet(2);
  42. bm.ReSet(2000);
  43. bm.ReSet(2000000);
  44. bm.ReSet(20000000);
  45. cout<<bm.Test(2)<<endl;
  46. cout<<bm.Test(20)<<endl;
  47. cout<<bm.Test(200)<<endl;
  48. cout<<bm.Test(2000)<<endl;
  49. cout<<bm.Test(20000)<<endl;
  50. cout<<bm.Test(200000)<<endl;
  51. cout<<bm.Test(2000000)<<endl;
  52. cout<<bm.Test(20000000)<<endl;
  53. }

运行结果：

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

布隆过滤器：

[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. template<class K = string,
  38. class HashFunc1 = __HashFunc1,
  39. class HashFunc2 = __HashFunc2,
  40. class HashFunc3 = __HashFunc3,
  41. class HashFunc4 = __HashFunc4,
  42. class HashFunc5 = __HashFunc5
  43. >
  44. class BloomFilter
  45. {
  46. public:
  47. BloomFilter(size_t N = 1024)
  48. :_bm(N * 10)
  49. ,_size(N * 10)
  50. {}
  51. void Set(const K& key)
  52. {
  53. size_t hash1 = HashFunc1()(key) % _size;
  54. size_t hash2 = HashFunc2()(key) % _size;
  55. size_t hash3 = HashFunc3()(key) % _size;
  56. size_t hash4 = HashFunc4()(key) % _size;
  57. size_t hash5 = HashFunc5()(key) % _size;
  58. _bm.Set(hash1);
  59. _bm.Set(hash2);
  60. _bm.Set(hash3);
  61. _bm.Set(hash4);
  62. _bm.Set(hash5);
  63. cout<<hash1<<":"<<hash2<<":"<<hash3<<":"<<hash4<<":"<<hash5<<endl;
  64. }
  65. //void ReSet(const K& key);//不支持
  66. bool Test(const K& key)
  67. {
  68. size_t hash1 = HashFunc1()(key) % _size;
  69. if (_bm.Test(hash1) == false)
  70. return false;
  71. size_t hash2 = HashFunc2()(key) % _size;
  72. if (_bm.Test(hash2) == false)
  73. return false;
  74. size_t hash3 = HashFunc3()(key) % _size;
  75. if (_bm.Test(hash3) == false)
  76. return false;
  77. size_t hash4 = HashFunc4()(key) % _size;
  78. if (_bm.Test(hash4) == false)
  79. return false;
  80. size_t hash5 = HashFunc5()(key) % _size;
  81. if (_bm.Test(hash5) == false)
  82. return false;
  83. return true;
  84. }
  85. protected:
  86. BitMap _bm;
  87. size_t _size;
  88. };

测试函数：

[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. cout<<bm.Test("http://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html")<<endl;
  10. cout<<bm.Test("http://www.cnblogs.com/-clq/archive/2012/05/31/2528158.html")<<endl;
  11. cout<<bm.Test("http://www.cnblogs.com/-clq/archive/2012/05/31/2528154.html")<<endl;
  12. }

运行结果：

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. _refbm[hash1]++;
  25. _refbm[hash2]++;
  26. _refbm[hash3]++;
  27. _refbm[hash4]++;
  28. _refbm[hash5]++;
  29. cout<<hash1<<":"<<hash2<<":"<<hash3<<":"<<hash4<<":"<<hash5<<endl;
  30. }
  31. void ReSet(const K& key)
  32. {
  33. size_t hash1 = HashFunc1()(key) % _size;
  34. size_t hash2 = HashFunc2()(key) % _size;
  35. size_t hash3 = HashFunc3()(key) % _size;
  36. size_t hash4 = HashFunc4()(key) % _size;
  37. size_t hash5 = HashFunc5()(key) % _size;
  38. _refbm[hash1]--;
  39. _refbm[hash2]--;
  40. _refbm[hash3]--;
  41. _refbm[hash4]--;
  42. _refbm[hash5]--;
  43. }
  44. bool Test(const K& key)
  45. {
  46. size_t hash1 = HashFunc1()(key) % _size;
  47. if (_refbm[hash1] <= 0)
  48. return false;
  49. size_t hash2 = HashFunc2()(key) % _size;
  50. if (_refbm[hash2] <= 0)
  51. return false;
  52. size_t hash3 = HashFunc3()(key) % _size;
  53. if (_refbm[hash3] <= 0)
  54. return false;
  55. size_t hash4 = HashFunc4()(key) % _size;
  56. if (_refbm[hash4] <= 0)
  57. return false;
  58. size_t hash5 = HashFunc5()(key) % _size;
  59. if (_refbm[hash5] <= 0)
  60. return false;
  61. return true;
  62. }
  63. protected:
  64. vector<size_t> _refbm;
  65. size_t _size;
  66. };

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

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

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

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

如下图：

原文地址：https://www.cnblogs.com/threetop/p/9161623.html

时间： 2024-11-10 01:25:38

经典大数据面试题的相关文章

Shell在大数据的魅力时代：从一点点思路百度大数据面试题

供Linux开发中的同学们,Shell这可以说是一个基本功. 对于同学们的操作和维护.Shell也可以说是一种必要的技能,Shell.对于Release Team,软件配置管理的同学来说.Shell也起到了非常关键的数据.尤其是分布式系统发展的如火如荼,非常多开源项目都开展的如火如荼(好像不是分布式的系统都不好意思拿出来说事).分布式系统的配置.管理,Shell也起到了非常关键的数据,尽管仅仅是简单的文件拷贝,可是谁让Shell天生是做这些的呢? 当然了,以上不是本文的主题.本文的主题是Shel

117道有关大数据面试题解析，希望对你有所帮助

一 .简述如何安装配置apache 的一个开源的hadoop 使用root账户登陆 2.修改ip 3.修改host主机名 4.配置ssh 免密登陆 5.关闭防火墙 6.安装JDK 7.解压hadoop安装包 8.配置hadoop的核心配置文件 hadoop-env.sh? core-site.xml? mapred-site.xml yarn-site.xml hdfs-site.xml 9.配置hadoop 的环境变量 10 .格式化hadoop namenode-format 启动节点sta

117道有关大数据面试题的解析，希望对你有所帮助！

一 .简述如何安装配置apache 的一个开源的hadoop 使用root账户登陆 2.修改ip 3.修改host主机名 4.配置ssh 免密登陆 5.关闭防火墙 6.安装JDK 7.解压hadoop安装包 8.配置hadoop的核心配置文件 hadoop-env.sh? core-site.xml? mapred-site.xml yarn-site.xml hdfs-site.xml 9.配置hadoop 的环境变量 10 .格式化hadoop namenode-format 启动节点sta

百余份经典大数据文档免费下载

您只需要添加[ITIL先锋]微信公众号,公众号的后台再回复您的邮箱地址,我们将在两天内把这一百多篇大数据文档的下载链接免费发送给您! 这些大数据文档只是迄今收集整理出的一些文档,后期我们还会不断的收集整理,补充更新.如果您有好的大数据文档,欢迎后台留言推荐给我们.或者您有什么需求,也欢迎留言,我们后期会根据大家的需求,再收集整理一些文档奉献给大家. 大数据文档 (2014)OpenKN--网络大数据时代 的知识计算引擎.pdf <云计算(第三版)>Google云计算原理与应用(二).pptx

2018年大数据面试题总结

目前面试了多家大数据开发工程师,成长了很多,也知道了很多知识,下面和大家分享一下我遇到的面试题和答案. 1.kafka集群的规模,消费速度是多少. 答:一般中小型公司是10个节点,每秒20M左右. 2.hdfs上传文件的流程. 答:这里描述的 是一个256M的文件上传过程 ① 由客户端 向 NameNode节点节点 发出请求 ②NameNode 向Client返回可以可以存数据的 DataNode 这里遵循机架感应原则 ③客户端 首先 根据返回的信息 先将 文件分块(Hadoop2.X版本 每一

大数据面试题分析

最近学习了hashtable的一点知识,发现可以用来解决大数据的一些问题.我们这里讲的大数据分析事实上并不是分布式和数据挖掘这些高深的概念,而是针对从从一个大文件或者一堆数据(内存放不下)中找出具有某种特点的数,这也是近年来各大公司经常考的问题. 面试题1:给一个超过100G大小的log file, log中存着IP地址, 设计算法找到出现次数最多的IP地址? 解析:100G的文件给我们的感觉是太大,我们的电脑内存一般都为4G左右所以不可能一次性把这么多的信息都加载到内存,所以就要进行切分成10

Hadoop大数据面试题（ 全）

以下资料来源于互联网,很多都是面试者们去面试的时候遇到的问题,我对其中有的问题做了稍许的修改了回答了部分空白的问题,其中里面有些考题出的的确不是很好,但是也不乏有很好的题目,这些都是基于真实的面试来的,希望对即将去面试或向继续学习hadoop,大数据等的朋友有帮助! 前言 有一句话叫做三人行必有我师,其实做为一个开发者,有一个学习的氛围跟一个交流圈子特别重要这是一个我的大数据交流学习群531629188不管你是小白还是大牛欢迎入驻,正在求职的也可以加入,大家一起交流学习,话糙理不糙,互相学习,共

大数据面试题整理

1.fsimage和edit的区别? 大家都知道namenode与secondary namenode 的关系,当他们要进行数据同步时叫做checkpoint时就用到了fsimage与edit,fsimage是保存最新的元数据的信息,当fsimage数据到一定的大小事会去生成一个新的文件来保存元数据的信息,这个新的文件就是edit,edit会回滚最新的数据. 2.列举几个配置文件优化? --发挥 1)Core-site.xml 文件的优化 a.fs.trash.interval,默认值: 0:说

大数据面试题汇总(不断更新中)

结合自身面试经历,包括BAT.SF.中信等等公司所做的面试题汇总.主要包括以下几大类: 一.spark相关 1.Spark的Shuffle原理及调优? 2.hadoop和spark使用场景? 3.spark如何保证宕机迅速恢复? 4.hadoop和spark的相同点和不同点? 5.RDD持久化原理? 6.checkpoint检查点机制? 7.checkpoint和持久化机制的区别? 8.Spark Streaming和Storm有何区别?  9.RDD机制?  10.Spark streamin