海量数据Top K算法

海量数据处理的Top K 算法就是在很大的文件中找出重复出现次数最多的前K个字符串；

如果数据可以一次读入内存，那么可以按照如下思路来解决：

（1）首先遍历文件，将其加入Hash链表；Hash链表的节点定义为：

 

typedef struct node
{
    char *word;
    int count;
    struct node *next;
}node,*node_ptr;

word指向字符串，count为出现的次数；

（2）建立一个容量为K的最小堆，然后遍历Hash表中剩下的元素；如果找到了一个元素的count值比这个元素值大，那么交换这个节点和堆顶节点；

完整全部代码如下：在Eclipse + CDT + mingw 下调试通过

程序有待完善的地方：

（1）存在一个位置bug:改变HASHLEN的值，程序崩溃；

（2）HASH链表的遍历不正确，应该遍历到每一个节点的时候，在判断该节点的next是否为空；

 

# include <stdio.h>
# include <string.h>
# include <malloc.h>
# include <assert.h>
# include <stdlib.h>
#define HASHLEN 101
#define WORDLEN 30
#define MAX  100000
#define DOMAIN 300
#define K 5
//Hash链表的节点定义
typedef struct node
{
    char *word;
    int count;
    struct node *next;
}node,*node_ptr;
static node_ptr head[HASHLEN];
static node array[K];
//Hash函数
int hash_function(char *p)
{
    unsigned int value = 0;
    while (*p != '\0')
    {
        value = value * 31 + *p++;
        if (value > HASHLEN)
            value = value % HASHLEN;
    }
    return value;
}
//加入节点到HASH链表
void append_word(char *str)
{
    int index = hash_function(str);
    node_ptr p = head[index];
    while (p != NULL)
    {
        if (strcmp(str, p->word) == 0)
        {
            (p->count)++;
            return;
        }
        p = p->next;
    }
    // 新建一个结点
    node_ptr q = (node_ptr)malloc(sizeof(node));
    q->count = 1;
    q->word = (char *)malloc(sizeof(str) + 1);
    strcpy(q->word, str);
//    q->word = str;
    q->next = head[index];
    head[index] = q;
}
//产生0~DOMAIN - 1范围内的MAX个整数
void gen_data()
{
    FILE *fp = fopen("c:\\data1.txt", "w");
    assert(fp);
    int i = 0;
    srand((int)(time(0)));
    for (i = 0; i < MAX; i++)
     fprintf(fp,"%d  ",rand()%DOMAIN);
    fclose(fp);
}
//堆调整:调整为最小堆
void heapAdjust(node array[], int beginIndex, int endIndex, int index)
{
 int length = endIndex - beginIndex + 1;
 int largestIndex = index;
 int leftIndex = 2 * index + 1;     //下标从0开始，可以自己做实验
 int rightIndex = 2 * index + 2;
 if (leftIndex <= length - 1 && array[leftIndex].count <= array[largestIndex].count )
  {
   largestIndex = leftIndex;
  }
 if (rightIndex <= length - 1 && array[rightIndex].count <= array[largestIndex].count )
  {
   largestIndex = rightIndex;
  }
 if (largestIndex != index)
  {
   node temp = array[largestIndex];
   array[largestIndex] = array[index];
   array[index] = temp;
   heapAdjust (array, beginIndex, endIndex, largestIndex);
  }
}
//建堆
void heapBuild (node array[], int len )
 {
  int i = 0;
  for (i = len/2 - 1; i >= 0; i --)
  {
   heapAdjust (array, 0, len - 1, i);
  }
 }

int main()
{
 gen_data();
 char str[WORDLEN];
// char *str;
 int i;
 int cnt1 = 0;
 for (i = 0; i < HASHLEN; i++)
    head[i] = NULL;
 FILE *fp_passage = fopen("c:\\data1.txt", "r");
 assert(fp_passage);
 while (fscanf(fp_passage, "%s", str) != EOF)
 {
     cnt1++;
     append_word(str);
    }
 printf("the cnt1 is %d\n", cnt1);
      fclose(fp_passage);
      //寻找Top K
 for(i = 0; i < HASHLEN; i++)
 {
  if(i < K - 1)
    array[i] = *head[i];
  else
   if(i == K - 1)
    {
    array[i] = *head[i];
    heapBuild(array,K);
    }
   else
   {
    if(array[0].count < head[i]->count)
    {
     array[0] = *head[i];
     heapAdjust(array,0,K - 1,0);
    }
   }
 }
 printf("the top K is as follows\n");
 for(i = 0; i < K; i++)
   printf("%s , and its count is %d\n",array[i].word, array[i].count);
// printf("the total number of word is %d",cnt);
 return 0;
}

 

 

运行结果：

100000个树中重复出现次数最多的前5个数：

the top K is as follows
49 , and its count is 372
4 , and its count is 374
249 , and its count is 373
246 , and its count is 380
227 , and its count is 376

 

1． 问题描述

在大规模数据处理中，常遇到的一类问题是，在海量数据中找出出现频率最高的前K个数，或者从海量数据中找出最大的前K个数，这类问题通常称为“top K”问题，如：在搜索引擎中，统计搜索最热门的10个查询词；在歌曲库中统计下载率最高的前10首歌等等。

2． 当前解决方案

针对top k类问题，通常比较好的方案是【分治+trie树/hash+小顶堆】，即先将数据集按照hash方法分解成多个小数据集，然后使用trie树或者hash统计每个小数据集中的query词频，之后用小顶堆求出每个数据集中出频率最高的前K个数，最后在所有top K中求出最终的top K。

实际上，最优的解决方案应该是最符合实际设计需求的方案，在实际应用中，可能有足够大的内存，那么直接将数据扔到内存中一次性处理即可，也可能机器有多个核，这样可以采用多线程处理整个数据集。

本文针对不同的应用场景，介绍了适合相应应用场景的解决方案。

3． 解决方案

3.1 单机+单核+足够大内存

设每个查询词平均占8Byte，则10亿个查询词所需的内存大约是10^9*8=8G内存。如果你有这么大的内存，直接在内存中对查询词进行排序，顺序遍历找出10个出现频率最大的10个即可。这种方法简单快速，更加实用。当然，也可以先用HashMap求出每个词出现的频率，然后求出出现频率最大的10个词。

3.2 单机+多核+足够大内存

这时可以直接在内存中实用hash方法将数据划分成n个partition，每个partition交给一个线程处理，线程的处理逻辑是同3.1节类似，最后一个线程将结果归并。

该方法存在一个瓶颈会明显影响效率，即数据倾斜，每个线程的处理速度可能不同，快的线程需要等待慢的线程，最终的处理速度取决于慢的线程。解决方法是，将数据划分成c*n个partition（c>1），每个线程处理完当前partition后主动取下一个partition继续处理，直到所有数据处理完毕，最后由一个线程进行归并。

3.3 单机+单核+受限内存

这种情况下，需要将原数据文件切割成一个一个小文件，如，采用hash(x)%M，将原文件中的数据切割成M小文件，如果小文件仍大于内存大小，继续采用hash的方法对数据文件进行切割，直到每个小文件小于内存大小，这样，每个文件可放到内存中处理。采用3.1节的方法依次处理每个小文件。

3.4 多机+受限内存

这种情况下，为了合理利用多台机器的资源，可将数据分发到多台机器上，每台机器采用3.3节中的策略解决本地的数据。可采用hash+socket方法进行数据分发。

从实际应用的角度考虑，3.1~3.4节的方案并不可行，因为在大规模数据处理环境下，作业效率并不是首要考虑的问题，算法的扩展性和容错性才是首要考虑的。算法应该具有良好的扩展性，以便数据量进一步加大（随着业务的发展，数据量加大是必然的）时，在不修改算法框架的前提下，可达到近似的线性比；算法应该具有容错性，即当前某个文件处理失败后，能自动将其交给另外一个线程继续处理，而不是从头开始处理。

Top k问题很适合采用MapReduce框架解决，用户只需编写一个map函数和两个reduce 函数，然后提交到Hadoop（采用mapchain和reducechain）上即可解决该问题。对于map函数，采用hash算法，将hash值相同的数据交给同一个reduce task；对于第一个reduce函数，采用HashMap统计出每个词出现的频率，对于第二个reduce 函数，统计所有reduce task输出数据中的top k即可。

4． 总结

Top K问题是一个非常常见的问题，公司一般不会自己写个程序进行计算，而是提交到自己核心的数据处理平台上计算，该平台的计算效率可能不如直接写程序高，但它具有良好的扩展性和容错性，而这才是企业最看重的。

5． 参考资料

《十道海量数据处理面试题与十个方法大总结》：