2. 程式人生 > >經典大資料面試題

經典大資料面試題

阿新 • • 發佈：2019-01-03

什麼是大資料？

大資料(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中找出最大的出現次數即為所求。

用到的雜湊函式：

template<class T>  
size_t BKDRHash(const T *str)  
{  
	register size_t hash = 0;  
	while (size_t ch = (size_t)*str++)  
	{         
		hash = hash * 131 + ch;   // 也可以乘以31、131、1313、13131、131313..          
	}  
	return hash;  
}




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)。
注意：重複出現的數字交集中只會出現一次。

點陣圖的簡單模擬：

//點陣圖：專門用來判斷資料是否存在，不能統計資料出現的次數
class BitMap
{
public:
	BitMap(size_t N = 1024)//N代表需要判斷的資料個數
	{
		_array.resize((N>>5) + 1);//相當於(N/32)+1,結果為需要開闢的位元組個數
	}

	void Set(size_t value)//將狀態由無置為有，即0變為1
	{
		size_t index = value >> 5;//代表整數的下標，即第幾個整數
		size_t num = value % 32;//代表第幾位
		
		_array[index] |= 1<<num;//將特定位置1
	}

	void ReSet(size_t value)//將狀態由有置為無，即1變為0
	{
		size_t index = value >> 5;//代表整數的下標，即第幾個整數
		size_t num = value % 32;//代表第幾位

		_array[index] &= (~(1<<num));//將特定位置0
	}

	bool Test(size_t value)
	{
		size_t index = value >> 5;//代表整數的下標，即第幾個整數
		size_t num = value % 32;//代表第幾位

		return _array[index] & (1<<num);
	}
protected:
	std::vector<size_t> _array;//每個size_t可判斷32個數是否存在
};

void TestBitMap()
{
	BitMap bm((size_t)-1);

	bm.Set(2);
	bm.Set(20);
	bm.Set(200);
	bm.Set(2000);
	bm.Set(20000);
	bm.Set(200000);
	bm.Set(2000000);
	bm.Set(20000000);

	bm.ReSet(2);
	bm.ReSet(2000);
	bm.ReSet(2000000);
	bm.ReSet(20000000);
	
	cout<<bm.Test(2)<<endl;
	cout<<bm.Test(20)<<endl;
	cout<<bm.Test(200)<<endl;
	cout<<bm.Test(2000)<<endl;
	cout<<bm.Test(20000)<<endl;
	cout<<bm.Test(200000)<<endl;
	cout<<bm.Test(2000000)<<endl;
	cout<<bm.Test(20000000)<<endl;
}
執行結果：







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)。
注意：布隆過濾器判斷不存在是確定的，而存存在在可能導致誤判，所以稱近似演算法。

布隆過濾器的簡單模擬：

各種不同的雜湊函式：



template<class T>  
size_t BKDRHash(const T *str)  
{  
	register size_t hash = 0;  
	while (size_t ch = (size_t)*str++)  
	{         
		hash = hash * 131 + ch;   // 也可以乘以31、131、1313、13131、131313..          
	}  
	return hash;  
}  
 
template<class T>  
size_t SDBMHash(const T *str)  
{  
	register size_t hash = 0;  
	while (size_t ch = (size_t)*str++)  
	{  
		hash = 65599 * hash + ch;         
		//hash = (size_t)ch + (hash << 6) + (hash << 16) - hash;  
	}  
	return hash;  
}  
  
template<class T>  
size_t RSHash(const T *str)  
{  
	register size_t hash = 0;  
	size_t magic = 63689;     
	while (size_t ch = (size_t)*str++)  
	{  
		hash = hash * magic + ch;  
		magic *= 378551;  
	}  
	return hash;  
}  

template<class T>  
size_t APHash(const T *str)  
{  
	register size_t hash = 0;  
	size_t ch;  
	for (long i = 0; ch = (size_t)*str++; i++)  
	{  
		if ((i & 1) == 0)  
		{  
			hash ^= ((hash << 7) ^ ch ^ (hash >> 3));  
		}  
		else  
		{  
			hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));  
		}  
	}  
	return hash;  
}  
  
template<class T>  
size_t JSHash(const T *str)  
{  
	if(!*str)        // 這是由本人新增，以保證空字串返回雜湊值0  
		return 0;  
	register size_t hash = 1315423911;  
	while (size_t ch = (size_t)*str++)  
	{  
		hash ^= ((hash << 5) + ch + (hash >> 2));  
	}  
	return hash;  
}  
template<class T>  
size_t DEKHash(const T* str)  
{  
	if(!*str)        // 這是由本人新增，以保證空字串返回雜湊值0  
		return 0;  
	register size_t hash = 1315423911;  
	while (size_t ch = (size_t)*str++)  
	{  
		hash = ((hash << 5) ^ (hash >> 27)) ^ ch;  
	}  
	return hash;  
}  
  
template<class T>  
size_t FNVHash(const T* str)  
{  
	if(!*str)   // 這是由本人新增，以保證空字串返回雜湊值0  
		return 0;  
	register size_t hash = 2166136261;  
	while (size_t ch = (size_t)*str++)  
	{  
		hash *= 16777619;  
		hash ^= ch;  
	}  
	return hash;  
}  
  
template<class T>  
size_t DJBHash(const T *str)  
{  
	if(!*str)   // 這是由本人新增，以保證空字串返回雜湊值0  
		return 0;  
	register size_t hash = 5381;  
	while (size_t ch = (size_t)*str++)  
	{  
		hash += (hash << 5) + ch;  
	}  
	return hash;  
}  

template<class T>  
size_t DJB2Hash(const T *str)  
{  
	if(!*str)   // 這是由本人新增，以保證空字串返回雜湊值0  
		return 0;  
	register size_t hash = 5381;  
	while (size_t ch = (size_t)*str++)  
	{  
		hash = hash * 33 ^ ch;  
	}  
	return hash;  
}  
 
template<class T>  
size_t PJWHash(const T *str)  
{  
	static const size_t TotalBits       = sizeof(size_t) * 8;  
	static const size_t ThreeQuarters   = (TotalBits  * 3) / 4;  
	static const size_t OneEighth       = TotalBits / 8;  
	static const size_t HighBits        = ((size_t)-1) << (TotalBits - OneEighth);      

	register size_t hash = 0;  
	size_t magic = 0;     
	while (size_t ch = (size_t)*str++)  
	{  
		hash = (hash << OneEighth) + ch;  
		if ((magic = hash & HighBits) != 0)  
		{  
			hash = ((hash ^ (magic >> ThreeQuarters)) & (~HighBits));  
		}  
	}  
	return hash;  
}  
  
template<class T>  
size_t ELFHash(const T *str)  
{  
	static const size_t TotalBits       = sizeof(size_t) * 8;  
	static const size_t ThreeQuarters   = (TotalBits  * 3) / 4;  
	static const size_t OneEighth       = TotalBits / 8;  
	static const size_t HighBits        = ((size_t)-1) << (TotalBits - OneEighth);      
	register size_t hash = 0;  
	size_t magic = 0;  
	while (size_t ch = (size_t)*str++)  
	{  
		hash = (hash << OneEighth) + ch;  
		if ((magic = hash & HighBits) != 0)  
		{  
			hash ^= (magic >> ThreeQuarters);  
			hash &= ~magic;  
		}         
	}  
	return hash;  
}
布隆過濾器： 
//布隆過濾器
struct __HashFunc1
{ 
	size_t operator()(const std::string& s)
	{
		return BKDRHash(s.c_str());
	}
};
struct __HashFunc2
{
	size_t operator()(const std::string& s)
	{
		return SDBMHash(s.c_str());
	}
};
struct __HashFunc3
{
	size_t operator()(const std::string& s)
	{
		return RSHash(s.c_str());
	}
};
struct __HashFunc4
{
	size_t operator()(const std::string& s)
	{
		return JSHash(s.c_str());
	}
};
struct __HashFunc5
{
	size_t operator()(const std::string& s)
	{
		return APHash(s.c_str());
	}
};


template<class K = string,
class HashFunc1 = __HashFunc1,
class HashFunc2 = __HashFunc2,
class HashFunc3 = __HashFunc3,
class HashFunc4 = __HashFunc4,
class HashFunc5 = __HashFunc5
>
class BloomFilter
{
public:
	BloomFilter(size_t N = 1024)
		:_bm(N * 10)
		,_size(N * 10)
	{}
	void Set(const K& key)
	{
		size_t hash1 = HashFunc1()(key) % _size;
		size_t hash2 = HashFunc2()(key) % _size;
		size_t hash3 = HashFunc3()(key) % _size;
		size_t hash4 = HashFunc4()(key) % _size;
		size_t hash5 = HashFunc5()(key) % _size;

		_bm.Set(hash1);
		_bm.Set(hash2);
		_bm.Set(hash3);
		_bm.Set(hash4);
		_bm.Set(hash5);

		cout<<hash1<<":"<<hash2<<":"<<hash3<<":"<<hash4<<":"<<hash5<<endl;
	}
	//void ReSet(const K& key);//不支援
	bool Test(const K& key)
	{
		size_t hash1 = HashFunc1()(key) % _size;
		if (_bm.Test(hash1) == false)
			return false;
		
		size_t hash2 = HashFunc2()(key) % _size;
		if (_bm.Test(hash2) == false)
			return false;

		size_t hash3 = HashFunc3()(key) % _size;
		if (_bm.Test(hash3) == false)
			return false;

		size_t hash4 = HashFunc4()(key) % _size;
		if (_bm.Test(hash4) == false)
			return false;

		size_t hash5 = HashFunc5()(key) % _size;
		if (_bm.Test(hash5) == false)
			return false;

		return true;
	}
protected:
	BitMap _bm;
	size_t _size;
};

測試函式： 
void TestBloomBitMap()
{
	BloomFilter<> bm(1024);
	bm.Set("http://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html");
	bm.Set("http://www.cnblogs.com/-clq/archive/2012/05/31/2528154.html");
	bm.Set("http://www.cnblogs.com/-clq/archive/2012/05/31/2528155.html");
	bm.Set("http://www.cnblogs.com/-clq/archive/2012/05/31/2528156.html");
	bm.Set("http://www.cnblogs.com/-clq/archive/2012/05/31/2528157.html");

	cout<<bm.Test("http://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html")<<endl;
	cout<<bm.Test("http://www.cnblogs.com/-clq/archive/2012/05/31/2528158.html")<<endl;
	cout<<bm.Test("http://www.cnblogs.com/-clq/archive/2012/05/31/2528154.html")<<endl;
}
執行結果：




7>如何擴充套件BloomFilter使得它支援刪除元素的操作？
答：因為一個布隆過濾器的key對應多個為位，衝突的 概率比較大，所以不支援刪除，因為刪除有可能影響 到其他元素。如果要對其元素進行刪除，就不得不對 每一個位進行引用計數，同下題。




8>如何擴充套件BloomFilter使得它支援計數的操作？
答：我們都知道，點陣圖非常的節省空間，但由於每一 位都要引入一個int,所以空間浪費還是比較嚴重的， 因此不得不放棄點陣圖了，程式碼如下：

//帶刪除功能的布隆過濾器（引用計數）
template<class K = string,
class HashFunc1 = __HashFunc1,
class HashFunc2 = __HashFunc2,
class HashFunc3 = __HashFunc3,
class HashFunc4 = __HashFunc4,
class HashFunc5 = __HashFunc5
>
class RefBloomFilter
{
public:
	RefBloomFilter(size_t N = 1024)
		:_size(N * 10)
	{
		_refbm.resize(_size);
	}
	void Set(const K& key)
	{
		size_t hash1 = HashFunc1()(key) % _size;
		size_t hash2 = HashFunc2()(key) % _size;
		size_t hash3 = HashFunc3()(key) % _size;
		size_t hash4 = HashFunc4()(key) % _size;
		size_t hash5 = HashFunc5()(key) % _size;

		_refbm[hash1]++;
		_refbm[hash2]++;
		_refbm[hash3]++;
		_refbm[hash4]++;
		_refbm[hash5]++;

		cout<<hash1<<":"<<hash2<<":"<<hash3<<":"<<hash4<<":"<<hash5<<endl;
	}
	void ReSet(const K& key)
	{
		size_t hash1 = HashFunc1()(key) % _size;
		size_t hash2 = HashFunc2()(key) % _size;
		size_t hash3 = HashFunc3()(key) % _size;
		size_t hash4 = HashFunc4()(key) % _size;
		size_t hash5 = HashFunc5()(key) % _size;

		_refbm[hash1]--;
		_refbm[hash2]--;
		_refbm[hash3]--;
		_refbm[hash4]--;
		_refbm[hash5]--;
	}
	bool Test(const K& key)
	{
		size_t hash1 = HashFunc1()(key) % _size;
		if (_refbm[hash1] <= 0)
			return false;

		size_t hash2 = HashFunc2()(key) % _size;
		if (_refbm[hash2] <= 0)
			return false;

		size_t hash3 = HashFunc3()(key) % _size;
		if (_refbm[hash3] <= 0)
			return false;

		size_t hash4 = HashFunc4()(key) % _size;
		if (_refbm[hash4] <= 0)
			return false;

		size_t hash5 = HashFunc5()(key) % _size;
		if (_refbm[hash5] <= 0)
			return false;

		return true;
	}
protected:
	vector<size_t> _refbm;
	size_t _size;
};






9>給上千個檔案，每一個檔案大小為1K-100M,給n個單 詞，設計演算法對每個詞找到所有包含它的檔案，你只 有100K記憶體。
答：對上千個檔案生成1000個布隆過濾器，並將1000 個布隆過濾器存入一個檔案中，將記憶體分為兩份，一 分用來讀取布隆過濾器中的詞，一塊用來讀取檔案， 直到每個布隆過濾器讀完為止。


吐舌頭用一個檔案info 準備用來儲存ｎ個詞和包含其的檔案資訊。
吐舌頭 首先把ｎ個詞分成ｘ份。對每一份用生成一個布 隆過濾器（因為對ｎ個詞只生成一個布隆過濾器，記憶體可能不夠用）。把生成的所有布隆過濾器存入外存 的一個檔案Filter中。
吐舌頭將記憶體分為兩塊緩衝區，一塊用於每次讀入一個 布隆過濾器，一個用於讀檔案(讀檔案這個緩衝區使用 相當於有界生產者消費者問題模型來實現同步)，大文 件可以分為更小的檔案，但需要儲存大檔案的標示信 息（如這個小檔案是哪個大檔案的）。
吐舌頭對讀入的每一個單詞用記憶體中的布隆過濾器來判 斷是否包含這個值，如果不包含，從Filter檔案中讀 取下一個布隆過濾器到記憶體，直到包含或遍歷完所有 布隆過濾器。如果包含,更新info 檔案。直到處理完 所有資料。刪除Filter檔案。


10>有一個詞典，包含N個英文單詞，現在任意給一個 字串，設計演算法找出包含這個字串的所有英文單 詞。
答：對於這道題目，我們要用到一種特殊的資料結 構----字典樹來解決它，所謂字典樹，又稱單詞查詢樹（或Trie樹），是一種雜湊樹的變種。
典型應用：用於統計、排序和儲存大量的字串，經 常被搜尋引擎系統用於文字詞頻統計。
優點：利用字串的公共字首來減少查詢時間，最大 限度地減少無謂的字串比較，查詢效率高於雜湊表 。
基本性質：吐舌頭根節點不包含字元，除根節點外每個節點 都只包含一個字元；
                   吐舌頭從根節點到某一節點，路徑上所有經過的字 符連線起來，為該節點對應的字串；
                   吐舌頭  每個節點的所有子節點包含的字元都不相同 。
應用：串的快速檢索、串排序、最長公共字首

解：
用給出的N個單詞建立一棵與上述字典樹不同的字典樹 ，用任意字串與字典樹中的每個節點中的單詞進行 比較，在每層中查詢與任意字串首字母一樣的，找到則遍歷其下面的子樹，找第二個字母，以此類推， 如果與任意字串的字元全部相同，則算找到。

如下圖：


相關推薦

經典大資料面試題

什麼是大資料？ 大資料(big data,mega data)，或稱巨量資料，指的是需要新處理模式才能具有更強的決策力、洞察力和流程優化能力的海量、高增長率和多樣化的資訊資產。 在維克托·邁爾-舍恩伯格及肯尼斯·庫克耶編寫的《大資料時代》中大資料指不用隨機分析法(抽樣調查)

大資料面試題01

Spark Application 使用者自己寫的程式，批處理作業的集合，Application的main方法時程式的入口，定義了RDD以及對RDD的操作 SparkContext spark的重要api，使用者邏輯與spark的互動介面。會和Cluster manager

網際網路大資料面試題集錦

原文地址:http://hbase.group/article/89 以下面試題都是群裡小夥伴提供的，現場真題(包含校招題)1.網易大資料面試題 說說專案 Spark哪部分用得好，如何調優 Java哪部分了解比較好 聊聊併發，併發實現方法，volatile關鍵字說說

網易杭研大資料面試題

一面： hdfs讀寫過程 MR原理 講專案 balabala... 差不多40幾分鐘吧 二面： 講專案，專案一個點一個點的問。 主要講的是PV、UV的統計、其中設計到rowkey衝突怎麼處理。 接著講專案balabala 差不多40多分鐘吧 HR面（一個男

2019最新大資料面試題及答案整理

大資料面試題總結一波，助力準備在金三銀四尋找好工作的小夥伴們，只有度過筆試這一關才能在下面的關卡中大展巨集圖！ 一、如何檢查namenode是否正常執行？重啟namenode的命令是什麼？ 通過節點資訊和瀏覽器檢視，通過指令碼監控 hadoop-daemon.sh start namenod

網際網路公司大資料面試題參考指南

以下面試題都是群裡小夥伴提供的，現場真題(包含校招題) 1.網易大資料面試題 說說專案 Spark哪部分用得好，如何調優 Java哪部分了解比較好 聊聊併發，併發實現方法，volatile關鍵字說說 HashMap的底層原理 為什麼要重寫hashcode和equ

大資料面試題分享之spark面試題

一  什麼是spark Spark是大資料的排程，監控和分配引擎。它是一個快速通用的叢集計算平臺.Spark擴充套件了流行的MapReduce模型.Spark提供的主要功能之一就是能夠在記憶體中執行計算 ，但對於在磁碟上執行的複雜應用程式，系統也比MapReduce更有效。

大資料面試題以及答案整理（一）

kafka的message包括哪些資訊 一個Kafka的Message由一個固定長度的header和一個變長的訊息體body組成 header部分由一個位元組的magic(檔案格式)和四個位元組的CRC32(用於判斷body訊息體是否正常)構成。當magic的值為

大資料面試題彙總版

作者 大資料面試題及答案 彙總版 當前版本： Ver 1.0 製作單位： 編寫人員： 審 核 人： 籤 收 人： 簽署日期：     201

2018年大資料面試題總結

目前面試了多家大資料開發工程師，成長了很多，也知道了很多知識，下面和大家分享一下我遇到的面試題和答案。 1.kafka叢集的規模，消費速度是多少。 答：一般中小型公司是10個節點，每秒20M左右。 2.hdfs上傳檔案的流程。 答：這裡描述的 是一個256M的檔

大資料面試題必會2018.01.07

資料分析師常見的10道面試題解答 1.海量日誌資料，提取出某日訪問百度次數最多的那個IP。 首先是這一天，並且是訪問百度的日誌中的IP取出來，逐個寫入到一個大檔案中，注意到IP是32位的，最多有個2*32個IP。同樣可以採用對映的方法，比如模1000，把整個大檔案對映為100

大資料面試題—7

9. 面試問題: 1.從前到後從你教育背景(學過哪些課)到各個專案你負責的模組,問的很細(本以為他是物理學博士,但是所有的技術都懂) 2.hadoop 的 namenode 宕機,怎麼解決 先分析宕機後的損失，宕機後直接導致client無法訪問，記憶體中的元資料丟失，但是硬碟中的元資料應該還存在

大資料面試題—6

3.14 1、一個Hadoop環境，整合了HBase和Hive，是否有必要給HDFS和Hbase都分別配置壓縮策略？請給出對壓縮策略的建議。 hdfs在儲存的時候不會將資料進行壓縮，如果想進行壓縮，我們可以在向hdfs上傳資料的時候進行壓縮。 1）、  採用壓縮流 2）、 &nb

2019最新大資料面試題 助力大家度過筆試關

　　大資料面試題總結一波，助力準備在金三銀四尋找好工作的小夥伴們，只有度過筆試這一關才能在下面的關卡中大展巨集圖!   　　一、如何檢查namenode是否正常執行?重啟namenode的命令是什麼? 　　通過節點資訊和瀏覽器檢視，通過指令碼監控 　　hadoop-d

你不知道的BAT大資料面試題

                         你不知道的BAT大資料面試題   1、kafka的message包括哪些資訊 一個Kafka的

30個常見的大資料面試題 --讓你的薪資更上一層

30個常見的大資料面試題： 包含spark、scala、storm、hadoop等常見的大資料處理工具； 常用的分散式資料庫如hbase、MongoDB、Redis等； 其他常用的java基礎、linux相關技術等 1.scala 語言有什麼特點，什

大資料面試題之Hadoop叢集搭建步驟

一、開啟需要搭建Hadoop叢集的主從節點伺服器 ，配置好靜態IP、主機名hostname、主機IP對映檔案hosts、關掉防火牆二、通過遠端登入工具（我用的是SecureSRT） 登入到Linux系統，登入前需要在Windows系統中C:\Windows\System32\

京東商城大資料面試題

Java篇 1、JVM，GC（演算法，新生代，老年代），JVM結構2、hashcode，hashMap，list，hashSet，equals（結構原理），A extends  B（類的載入順序）1.父類靜態程式碼塊；2.子類靜態程式碼塊；3.父類非靜態程式碼塊；4.父類

大資料面試題之2018.01.05

5.簡述Hadoop1和Hadoop2架構異同 Hadoop2相比較於Hadoop1來說，HDFS的架構與Mapreduce的都有較大的變化，且速度上和可用性上都有了很大的提高，Hadoop2中有兩個重要的變更。 1 Hdfs的NameNodes可以以叢集方

網易大資料面試題試解

       上週無意中看到了一份網易的面試題，說明為大資料部的面試題，粗略的看了一下，覺得挺有趣的，所以嘗試著進行一下解答，首先要吐槽下，不知道這是什麼級別崗位的題目，感覺有些不夠專業，對大資料能力考察的題目幾乎沒有，大多是比較寬泛的問題，感覺各個崗位面試都可以問的那些問