面试题集锦--海量数据+全排列

清疚 2021-09-15 17:04 433阅读 0赞

### 问题：某海量用户网站，用户拥有积分，积分可能会在使用过程中随时更新。现在要为该网站设计一种算法，在每次用户登录时显示其当前积分排名。用户最大规模为2亿；积分为非负整数，且小于100万。 ###

PS: 这是2013年暴风影音的最后一道试题，我做的试卷E，据说这还曾是迅雷的一道面试题，现在参考着网上的智慧，自己总结如下。

### 存储结构 ###

首先，我们用一张用户积分表user\_score来保存用户的积分信息。

表结构：

![userscoreschema][user_em _score_em_schema]

示例数据：

![userscoresample][user_em _score_em_sample]

下面的算法会基于这个基本的表结构来进行。

### 算法1：简单SQL查询 ###

首先，我们很容易想到用一条简单的SQL语句查询出积分大于该用户积分的用户数量：

select 1 + count(t2.uid) as rank from user_score t1, user_score t2 where t1.uid = @uid and t2.score > t1.score

对于4号用户我们可以得到下面的结果：

![sql\_1][sql_1]

算法特点

优点：简单，利用了SQL的功能，不需要复杂的查询逻辑，也不引入额外的存储结构，对小规模或性能要求不高的应用不失为一种良好的解决方案。

缺点：需要对user\_score表进行全表扫描，还需要考虑到查询的同时若有积分更新会对表造成锁定，在海量数据规模和高并发的应用中，性能是无法接受的。

### 算法2：均匀分区设计 ###

在许多应用中缓存是解决性能问题的重要途径，我们自然会想能不能把用户排名用Memcached缓存下来呢？不过再一想发现缓存似乎帮不上什么忙，因为用户排名是一个全局性的统计性指标，而并非用户的私有属性，其他用户的积分变化可能会马上影响到本用户的排名。然而，真实的应用中积分的变化其实也是有一定规律的，通常一个用户的积分不会突然暴增暴减，一般用户总是要在低分区混迹很长一段时间才会慢慢升入高分区，也就是说用户积分的分布总体说来是有区段的，我们进一步注意到高分区用户积分的细微变化其实对低分段用户的排名影响不大。于是，我们可以想到按积分区段进行统计的方法，引入一张分区积分表score\_range：

表结构：

![scorerangeschema][score_em _range_em_schema]

数据示例：

![scorerangesample][score_em _range_em_sample]

表示\[from\_score, to\_score)区间有count个用户。若我们按每1000分划分一个区间则有\[0, 1000), \[1000, 2000), …, \[999000, 1000000)这1000个区间，以后对用户积分的更新要相应地更新score\_range表的区间值。在分区积分表的辅助下查询积分为s的用户的排名，可以首先确定其所属区间，把高于s的积分区间的count值累加，然后再查询出该用户在本区间内的排名，二者相加即可获得用户的排名。

乍一看，这个方法貌似通过区间聚合减少了查询计算量，实则不然。最大的问题在于如何查询用户在本区间内的排名呢？如果是在算法1中的SQL中加上积分条件：

select 1 + count(t2.uid) as rank from user_score t1, user_score t2 where t1.uid = @uid and t2.score > t1.score and t2.score < @to_score

在理想情况下，由于把t2.score的范围限制在了1000以内，如果对score字段建立索引，我们期望本条SQL语句将通过索引大大减少扫描的user\_score表的行数。不过真实情况并非如此，t2.score的范围在1000以内并不意味着该区间内的用户数也是1000，因为这里有积分相同的情况存在！二八定律告诉我们，前20%的低分区往往集中了80%的用户，这就是说对于大量低分区用户进行区间内排名查询的性能远不及对少数的高分区用户，所以在一般情况下这种分区方法不会带来实质性的性能提升。

算法特点

优点：注意到了积分区间的存在，并通过预先聚合消除查询的全表扫描。

缺点：积分非均匀分布的特点使得性能提升并不理想。

### 算法3：树形分区设计 ###

均匀分区查询算法的失败是由于积分分布的非均匀性，那么我们自然就会想，能不能按二八定律，把score\_range表设计为非均匀区间呢？比如，把低分区划密集一点，10分一个区间，然后逐渐变成100分，1000分，10000分 … 当然，这不失为一种方法，不过这种分法有一定的随意性，不容易把握好，而且整个系统的积分分布会随着使用而逐渐发生变化，最初的较好的分区方法可能会变得不适应未来的情况了。我们希望找到一种分区方法，既可以适应积分非均匀性，又可以适应系统积分分布的变化，这就是树形分区。

我们可以把\[0, 1,000,000)作为一级区间；再把一级区间分为两个2级区间\[0, 500,000), \[500,000, 1,000,000)，然后把二级区间二分为4个3级区间\[0, 250,000), \[250,000, 500,000), \[500,000, 750,000), \[750,000, 1,000,000)，依此类推，最终我们会得到1,000,000个21级区间\[0,1), \[1,2) … \[999,999, 1,000,000)。这实际上是把区间组织成了一种平衡二叉树结构，根结点代表一级区间，每个非叶子结点有两个子结点，左子结点代表低分区间，右子结点代表高分区间。树形分区结构需要在更新时保持一种不变量(Invariant)：非叶子结点的count值总是等于其左右子结点的count值之和。

![range\_tree][range_tree]

以后，每次用户积分有变化所需要更新的区间数量和积分变化量有关系，积分变化越小更新的区间层次越低。总体上，每次所需要更新的区间数量是用户积分变量的log(n)级别的，也就是说如果用户积分一次变化在百万级，更新区间的数量在二十这个级别。在这种树形分区积分表的辅助下查询积分为s的用户排名，实际上是一个在区间树上由上至下、由粗到细一步步明确s所在位置的过程。比如，对于积分499,000，我们用一个初值为0的排名变量来做累加；首先，它属于1级区间的左子树\[0, 500,000)，那么该用户排名应该在右子树\[500,000, 1,000,000)的用户数count之后，我们把该count值累加到该用户排名变量，进入下一级区间；其次，它属于3级区间的\[250,000, 500,000)，这是2级区间的右子树，所以不用累加count到排名变量，直接进入下一级区间；再次，它属于4级区间的…；直到最后我们把用户积分精确定位在21级区间\[499,000, 499,001)，整个累加过程完成，得出排名！

虽然，本算法的更新和查询都涉及到若干个操作，但如果我们为区间的from\_score和to\_score建立索引，这些操作都是基于键的查询和更新，不会产生表扫描，因此效率更高。另外，本算法并不依赖于关系数据模型和SQL运算，可以轻易地改造为NoSQL等其他存储方式，而基于键的操作也很容易引入缓存机制进一步优化性能。进一步，我们可以估算一下树形区间的数目大约为2,000,000，考虑每个结点的大小，整个结构只占用几十M空间。所以，我们完全可以在内存建立区间树结构，并通过user\_score表在O(n)的时间内初始化区间树，然后排名的查询和更新操作都可以在内存进行。一般来讲，同样的算法，从数据库到内存算法的性能提升常常可以达到10^5以上；因此，本算法可以达到非常高的性能。

算法特点

优点：结构稳定，不受积分分布影响；每次查询或更新的复杂度为积分最大值的O(log(n))级别，且与用户规模无关，可以应对海量规模；不依赖于SQL，容易改造为NoSQL或内存数据结构。

缺点：算法相对更复杂。

### 算法4：积分排名数组 ###

算法3虽然性能较高，达到了积分变化的O(log(n))的复杂度，但是实现上比较复杂。另外，O(log(n))的复杂度只在n特别大的时候才显出它的优势，而实际应用中积分的变化情况往往不会太大，这时和O(n)的算法相比往往没有明显的优势，甚至可能更慢。

考虑到这一情况，仔细观察一下积分变化对排名的具体影响，可以发现某用户的积分从s变为s+n，积分小于s或者大于等于s+n的其他用户排名实际上并不会受到影响，只有积分在\[s,s+n)区间内的用户排名会下降1位。我们可以用于一个大小为1,000,000的数组表示积分和排名的对应关系，其中rank\[s\]表示积分s所对应的排名。初始化时，rank数组可以由user\_score表在O(n)的复杂度内计算而来。用户排名的查询和更新基于这个数组来进行。查询积分s所对应的排名直接返回rank\[s\]即可，复杂度为O(1)；当用户积分从s变为s+n，只需要把rank\[s\]到rank\[s+n-1\]这n个元素的值增加1即可，复杂度为O(n)。

算法特点

优点：积分排名数组比区间树更简单，易于实现；排名查询复杂度为O(1)；排名更新复杂度O(n)，在积分变化不大的情况下非常高效。

缺点：当n比较大时，需要更新大量元素，效率不如算法3。

### 总结 ###

上面介绍了用户积分排名的几种算法，算法1简单易于理解和实现，适用于小规模和低并发应用；算法3引入了更复杂的树形分区结构，但是O(log(n))的复杂度性能优越，可以应用于海量规模和高并发；算法4采用简单的排名数组，易于实现，在积分变化不大的情况下性能不亚于算法3。本问题是一个开放性的问题，相信一定还有其他优秀的算法和解决方案，欢迎探讨！

问题：找出一堆数据中最大或者最小的K个数

解答：找出最大的K个数方法是建立一个有K个数的最小堆。

#include <iostream>
 #include <vector>
 #include <set>
 using namespace std;
 typedef multiset< int,less<int> > INTHEAP;
 void FindGreatestNum(vector<int>& iArray, const unsigned int num, INTHEAP& pRes)
 {
 	pRes.clear();
 	if(iArray.empty() || num <= 0)
 	{
 		return;
 	}
 	vector<int>::iterator iter = iArray.begin();
 	while(iter != iArray.end())
 	{
 		if(pRes.size() < num)
 		{
 			pRes.insert(*iter);
 		}
 		else
 		{
 			INTHEAP::iterator pIter = pRes.begin();
 			if(*iter > *pIter)
 			{
 				pRes.erase(pIter);
 				pRes.insert(*iter); 
 			}
 		}
 		iter ++;
 	}
 }
 int main()
 {
 	int iArray[] = {1,6,9,0,2,8,12,77,90,54,78,92,23,34,56,76,91};
 	int len = sizeof( iArray ) / sizeof( int );
 	const unsigned int num = 7;
 	vector<int> nArray(iArray, iArray + len);
 	INTHEAP pRes;
 	FindGreatestNum(nArray, num, pRes);
 	INTHEAP::iterator iter = pRes.begin();
 	while(iter != pRes.end())
 	{
 		cout<<*iter<<" ";
 		iter ++;
 	}
 	cout<<endl;
 	return 0;
 }

同理：找出最小的K个数方法是建立一个有K个数的最大堆。

#include <iostream>
 #include <set>
 #include <vector>
 using namespace std;
 typedef multiset<int, greater < int > > intHeap;
 void FindKLeastNumbers(vector< int >& iArray,const unsigned int num,intHeap& pResult)
 {
 	pResult.clear();
 	if(iArray.empty() || num <= 0)
 	{
 		return;
 	}
 	for(vector<int>::iterator iter = iArray.begin(); iter != iArray.end(); iter ++)
 	{
 		if(pResult.size() < num)
 		{
 			pResult.insert(*iter);
 		}
 		else
 		{
 			multiset<int, greater<int> >::iterator pIter = pResult.begin();
 
 			if(*iter < *(pResult.begin()))
 			{
 				pResult.erase(pIter);
 
 				pResult.insert(*iter);
 			}
 		}
 	}
 }
 
 int main()
 {
 	int iArray[] = {1,9,7,8,5,3,9,4,2};
 	int len = sizeof( iArray ) / sizeof( int );
 	vector< int > nArray(iArray, iArray + len);
 	const unsigned int num = 4;
 	intHeap pResult;
 	FindKLeastNumbers(nArray, num, pResult);
 	multiset<int, greater<int> >::iterator iter = pResult.begin();
 	while(iter != pResult.end())
 	{
 		cout<<*iter<<" ";
 		iter ++;
 	}
 	cout<<endl;
 	return 0;
 }

同理：找出最小的K个数方法是建立一个有K个数的最大堆。同理：找出最小的K个数方法是建立一个有K个数的最大堆。

全排列算法 一 递归求解

集合R=\{1,2,3,4\}的全排列

可以分解为：1,\{2,3,4\}的全排列 + 2,\{1,3,4\}的全排列 + 3,\{1,2,4\}的全排列 + 4,\{1,2,3\}的全排列。

继续分解：\{2,3,4\} 为 2,\{3,4\}的全排列，3,\{2,4\},  4,\{2,3\}………………………………

…………

直到集合里只有一个元素，就可直接输出了.

#include <iostream>
 
 using namespace std;
 
 //char * str;
 //int len = 2;
 
 /**
 *产生list[start:end]的所有排列, 通常为0，len-1
 */
 template <class Type>
 void Perm(Type list[],int start,int end){
 
 	//单元素序列
 	if( start == end){ //即此时集合里只有一个元素
 		for(int i=0; i<=end; i++)
 			cout << list[i];
 		cout << endl;
 	}
 
 	//多元素序列，递归产生排列
 	else{
 		for(int i= start; i<= end; i++){
 			Swap(list[start], list[i]);//交换可得：1,{2,3,4} ; 2,{1,3,4}; 3,{1,2,4}; 4,{1,2,3}
 			
 			Perm(list, start+1, end);
 			Swap(list[start], list[i]);//输出排列之后，要再交换回到初始状态:{1,2,3,4}
 			
 
 		}
 	}
 
 }
 
 
 template <class Type>
 inline void Swap(Type &a, Type &b){
 	Type temp = a;
 	a = b;
 	b = temp;
 }
 
 
 
 int main() {
 	char str[] = "abcd";
 	Perm(str, 0,3);
 
 	//cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!!
 	return 0;
 }

全排列参考：[http://blog.csdn.net/morewindows/article/details/7370155][http_blog.csdn.net_morewindows_article_details_7370155]

[user_em _score_em_schema]: /images/20210522/63a2574f2c4e4d12b1078a2383bf7c52.png
[user_em _score_em_sample]: /images/20210522/07790efc9c68495e89bb94e6c054a052.png
[sql_1]: /images/20210522/3e6979c695224edfba12201ae7f0d710.png
[score_em _range_em_schema]: /images/20210522/6cacf7565bb5438d8c757166bfb16c2b.png
[score_em _range_em_sample]: /images/20210522/fffcd25ccc044f23ad2bdbf44c7ef657.png
[range_tree]: /images/20210522/ac556f390161448887710c02c29e930d.png
[http_blog.csdn.net_morewindows_article_details_7370155]: http://blog.csdn.net/morewindows/article/details/7370155