04Top K算法问题

        本章阐述寻找最小的k个数的反面，即寻找最大的k个数，尽管寻找最大的k个树和寻找最小的k个数，本质上是一样的。但这个寻找最大的k个数的问题的实用范围更广，因为它牵扯到了一个Top K算法问题，以及有关搜索引擎，海量数据处理等广泛的问题，所以本文特意对这个Top K算法问题，进行阐述以及实现。

 

一：寻找最大的k个数

        把之前第三章的问题，改几个字，即成为寻找最大的k个数的问题了，如下所述：

题目描述：

        输入n个整数，输出其中最大的k个。

        例如输入1，2，3，4，5，6，7和8这8个数字，则最大的4个数字为8，7，6和5。

 

分析：

        由于寻找最大的k个数的问题与之前的寻找最小的k个数的问题，本质是一样的，所以，这里就简单阐述下一个思路：

        维护k个元素的最小堆，即用容量为k的最小堆存储最先遍历到的k个数，建堆费时O（k），并调整堆（费时O（logk））。继续遍历数列，每次遍历一个元素x，与堆顶元素比较，若x>kmin，则更新堆（用时logk），否则不更新堆。这样下来，总费时O（k*logk+（n- k）*logk）=O（n*logk）。

        本文之后的例子主要采用这种思路，剩下的思路不在赘述。

 

二：搜索引擎热门查询统计

题目描述：

        搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。

        假设目前有一千万个记录（这些查询串的重复度比较高，虽然总数是1千万，但如果除去重复后，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门），请统计最热门的10个查询串，要求使用的内存不能超过1G。

 

分析：

        第一步、先对这批海量数据预处理，在O（N）的时间内用Hash表完成统计；

        第二步、借助堆这个数据结构，找出Top K，时间复杂度为N*logK。或者：采用trie树，关键字域存该查询串出现的次数，没有出现为0。最后用10个元素的最小推来对出现频率进行排序。

        为了降低实现上的难度，假设这些记录全部是一些英文单词, ok，复杂问题简单化了之后，编写代码实现也相对轻松多了，下面为部分代码：

 

// 结点指针 

typedef  struct  node_no_space *ptr_no_space;                //for  hashtable

typedef  struct  node_has_space *ptr_has_space;             //for  heap

ptr_no_space  head[HASHLEN];  //hash表

 

struct  node_no_space  

{ 

    char  *word; 

    int  count; 

    ptr_no_space  next; 

}; 

 

struct  node_has_space 

{ 

    char  word[WORDLEN]; 

    int  count; 

    ptr_has_space  next; 

}; 

 

// 最简单hash函数 

int  hash_function(char const  *p) 

{  

    int  value = 0; 

    while (*p !='/0') 

    { 

        value  =  value* 31  +  *p++; 

        if (value  >  HASHLEN) 

            value  =  value %  HASHLEN; 

    } 

    return  value; 

} 

 

// 添加单词到hash表 

void  append_word(char  const  *str)   

{   

    int index = hash_function(str); 

    ptr_no_space  p = head[index]; 

    while (p != NULL) 

    { 

        if (strcmp(str,  p->word) == 0) 

        { 

            (p->count)++; 

            return; 

        } 

        p = p->next; 

    } 

      

    // 新建一个结点 

    ptr_no_space  q =  new node_no_space; 

    q->count = 1; 

    q->word = new char [strlen(str)+1]; 

    strcpy(q->word, str); 

    q->next = head[index]; 

    head[index] = q; 

} 

    

// 将哈希表结果写入文件 

void  write_to_file() 

 

// 从上往下筛选，维持最小堆性质 

void  shift_down(node_has_space  heap[],  int i,  int  len) 

 

// 建立小根堆 

void  build_min_heap(node_has_space  heap[], int len) 

 

// 去除字符串前后符号 

void  handle_symbol(char  *str,  int n) 

 

int  main(int  argc,  char **argv) 

{ 

         if(argc  !=  2)

         {

                  printf("argu  error\n");

                  return  -1;

         }

         //初始化哈希表

    char  str[WORDLEN]; 

    for (int  i = 0;  i< HASHLEN;  i++) 

        head[i] = NULL; 

     

    // 读取文件，建立哈希表

    FILE  *fp_passage = fopen(argv[1],  "r"); 

    assert(fp_passage); 

    while (fscanf(fp_passage,  "%s",  str) != EOF) 

    { 

        int  n = strlen(str) - 1; 

        if (n > 0) 

            handle_symbol(str,  n); 

       append_word(str); 

    } 

    fclose(fp_passage); 

     

    // 将统计结果输入文件 

    write_to_file(); 

     

    int  n= 10; 

    ptr_has_space  heap = new  node_has_space [n+1]; 

     

    int  c; 

     

    FILE  *fp_word = fopen("result.txt",  "r"); 

    assert(fp_word); 

    for (int  j = 1;  j <= n;  j++) 

    { 

        fscanf(fp_word, "%s%d",  &str,  &c); 

        heap[j].count = c; 

        strcpy(heap[j].word, str); 

    } 

     

    // 建立最小堆 

    build_min_heap(heap, n); 

     

    // 查找出现频率最大的10个单词 

    while (fscanf(fp_word, "%s %d",&str, &c) != EOF) 

    { 

        if (c > heap[1].count) 

        { 

            heap[1].count = c; 

            strcpy(heap[1].word, str); 

            sift_down(heap, 1, n); 

        } 

    } 

    fclose(fp_word); 

     

    // 输出出现频率最大的单词 

    for (int k = 1; k <= n; k++) 

        cout << heap[k].count <<" " << heap[k].word << endl; 

     

    return 0; 

} 

 

三：统计出现次数最多的数据

题目描述：

        给你上千万或上亿数据（有重复），统计其中出现次数最多的前N个数据。

分析：

        上千万或上亿的数据，现在的机器的内存应该能存下（也许可以，也许不可以）。所以考虑采用hash_map/搜索二叉树/红黑树等来进行统计次数。然后就是取出前N个出现次数最多的数据了。当然，也可以堆实现。

此题与上题类似，最好的方法是用hash_map统计出现的次数，然后再借用堆找出出现次数最多的N个数据。不过，上一题统计搜索引擎最热门的查询已经采用过hash表统计单词出现的次数，特此，        本题改用红黑树取代之前的用hash表，来完成最初的统计，然后用堆更新，找出出现次数最多的前N个数据。下面为部分代码：

typedef  enum  rb_color{ RED,  BLACK } RB_COLOR; 

typedef  struct  rb_node 

{ 

    int  key; 

    int  data; 

    RB_COLOR  color; 

    struct  rb_node * left; 

    struct  rb_node * right; 

    struct  rb_node * parent; 

}RB_NODE; 

 

RB_NODE  * RB_CreatNode(int  key,  int data) 

 

/*左旋*/   

RB_NODE  * RB_RotateLeft(RB_NODE  * node,  RB_NODE * root) 

 

/* 右旋 */   

RB_NODE  * RB_RotateRight(RB_NODE  * node,  RB_NODE * root)   

 

/*红黑树查找结点*/ 

RB_NODE  *RB_SearchAuxiliary(int key, RB_NODE* root, RB_NODE** save)   

 

/* 返回上述rb_search_auxiliary查找结果 */ 

RB_NODE  *RB_Search(int key, RB_NODE* root)   

 

/* 红黑树的插入*/ 

RB_NODE  *RB_Insert(int key, int data, RB_NODE* root)   

 

typedef  struct  rb_heap 

{ 

    int  key;  //key表示数值本身

    int  data;  //data表示该数值出现次数

}RB_HEAP; 

const  int  heapSize = 10; 

RB_HEAP  heap[heapSize+1]; 

 

/*MAX_HEAPIFY函数对堆进行更新，使以i为根的子树成最小堆 */ 

void  MIN_HEAPIFY(RB_HEAP* A, const int& size,int i) 

 

/*BUILD_MINHEAP函数对数组A中的数据建立最小堆*/ 

void  BUILD_MINHEAP(RB_HEAP * A,  const  int & size) 

 

//中序遍历RBTree 

void  InOrderTraverse(RB_NODE  * node)   

{ 

    if (node  ==  NULL)   

    {   

        return;   

    }   

    else   

    {   

        InOrderTraverse(node->left);   

        if(node->data > heap[1].data) //当前节点data大于最小堆的最小元素，更新堆数据 

        { 

             heap[1].data = node->data; 

             heap[1].key= node->key; 

            MIN_HEAPIFY(heap, heapSize, 1); 

        } 

        InOrderTraverse(node->right);   

    } 

}  

 

void  RB_Destroy(RB_NODE  * node) 

 

int  main() 

{ 

    RB_NODE  * root = NULL; 

    RB_NODE  * node = NULL;   

     

    // 初始化最小堆 

    for (int i = 1; i <= 10; ++i) 

    { 

        heap[i].key = i; 

        heap[i].data = -i; 

    } 

    BUILD_MINHEAP(heap,  heapSize); 

     

    FILE* fp = fopen("data.txt","r"); 

    int num; 

    while (!feof(fp)) 

    { 

                  int res = -1;

                  res = fscanf(fp,"%d", &num);

                  if(res > 0)

                  {

                          root = RB_Insert(num, 1, root); 

                  }

                  else

                  {

                          break;

                  }

           

         } 

    fclose(fp); 

     

    InOrderTraverse(root);   //递归遍历红黑树 

    RB_Destroy(root); 

     

    for (i = 1; i <= 10; ++i) 

    { 

        printf("%d/t%d/n",heap[i].key, heap[i].data); 

    }    

    return 0; 

}  

 

        由于在遍历红黑树采用的是递归方式比较耗内存，可以采用一个非递归的遍历的程序。

 

        下面是用hash和堆解决此题，很明显比采用上面的红黑树，整个实现简洁了不少，部分源码如下：

#define  HASHTABLESIZE    2807303 

#define  HEAPSIZE                         10 

#define  A  0.6180339887       // (A )

#define  M  16384                 //m=2^14 

 

typedef  struct  hash_node 

{ 

    int  data; 

    int  count; 

    struct  hash_node* next; 

}HASH_NODE; 

HASH_NODE  * hash_table[HASHTABLESIZE]; 

 

HASH_NODE  * creat_node(int  & data) 

{ 

    HASH_NODE * node = (HASH_NODE*)malloc(sizeof(HASH_NODE)); 

     

    if (NULL == node) 

    { 

        printf("malloc  node  failed!/n"); 

        exit(EXIT_FAILURE); 

    } 

     

    node->data = data; 

    node->count = 1; 

    node->next = NULL; 

    return  node; 

} 

 

/** 

* hash函数采用乘法散列法

* h(k)=int(m*(A*k mod 1))

*/ 

int  hash_function(int  & key)   

{   

    double  result = A * key; 

    return  (int)(M * (result - (int)result));   

} 

 

void  insert(int  & data) 

{ 

    int  index =  hash_function(data); 

    HASH_NODE * pnode  =  hash_table[index]; 

    while (NULL  !=  pnode) 

    {  // 以存在data，则count++ 

        if (pnode->data == data) 

        { 

            pnode->count += 1; 

            return; 

        } 

        pnode = pnode->next; 

    } 

     

    // 建立一个新的节点，在表头插入 

    pnode  =  creat_node(data); 

    pnode->next  =  hash_table[index]; 

    hash_table[index] = pnode; 

} 

 

typedef  struct  min_heap 

{ 

    int  count; 

    int  data; 

}MIN_HEAP; 

MIN_HEAP heap[HEAPSIZE + 1]; 

 

/** 

*traverse_hashtale函数遍历整个hashtable，更新最小堆

*/ 

void  traverse_hashtale() 

{ 

    HASH_NODE  * p = NULL; 

    for (int  i = 0;  i< HASHTABLESIZE;  ++i) 

    { 

        p = hash_table[i]; 

        while (NULL != p) 

        {  // 如果当前节点的数量大于最小堆的最小值，则更新堆 

            if (p->count >heap[1].count) 

            { 

               heap[1].count = p->count; 

               heap[1].data = p->data; 

               min_heapify(heap, HEAPSIZE, 1); 

            } 

            p = p->next; 

        } 

    } 

} 

 

intmain() 

{ 

    // 初始化最小堆 

    for (int i = 1; i <= 10; ++i) 

    { 

        heap[i].count = -i; 

        heap[i].data = i; 

    } 

    build_min_heap(heap,  HEAPSIZE); 

     

    FILE* fp = fopen("data.txt","r"); 

    int  num; 

    while (!feof(fp)) 

    { 

                  intres = -1;

                  res =fscanf(fp, "%d", &num);

                  if(res> 0)

                  {

                          insert(num); 

                  }

                  else

                  {

                          break;

                  }    

      } 

    fclose(fp); 

     

    traverse_hashtale(); 

     

    for (i = 1; i <= 10; ++i) 

    { 

        printf("%d\t%d\n",heap[i].data, heap[i].count); 

    } 

     

    return 0; 

}  

 

四：海量数据处理问题一般总结

        关于海量数据处理的问题，一般有Bloom filter，Hashing，bit-map，堆，trie树等方法来处理。更详细的介绍，请查看此文：十道海量数据处理面试题与十个方法大总结。

 

        首先TopK问题，肯定需要有并发的，否则串行搞肯定慢，IO和计算重叠度不高。其次在IO上需要一些技巧，当然可能只是验证算法，在实践中IO的提升会非常明显。最后上文的代码可读性虽好，但机器的感觉可能就会差，这样会影响性能。(比如读文件的函数使用fscanf)

        同时，TopK可以看成从地球上选拔k个跑的最快的，参加奥林匹克比赛，各个国家自行选拔，各个大洲选拔，层层选拔，最后找出最快的10个。发挥多机多核的优势。

 

 

http://blog.csdn.net/v_JULY_v/article/details/6403777