PTA 哈希查找 除留取余法

PTA 电话聊天狂人（25 分）

给定大量手机用户通话记录，找出其中通话次数最多的聊天狂人。

输入格式:

输入首先给出正整数N（≤10​5​​），为通话记录条数。随后N行，每行给出一条通话记录。简单起见，这里只列出拨出方和接收方的11位数字构成的手机号码，其中以空格分隔。

输出格式:

在一行中给出聊天狂人的手机号码及其通话次数，其间以空格分隔。如果这样的人不唯一，则输出狂人中最小的号码及其通话次数，并且附加给出并列狂人的人数。

输入样例:

4
13005711862 13588625832
13505711862 13088625832
13588625832 18087925832
15005713862 13588625832

输出样例:

13588625832 3

思路分析：

本题要找通话次数最多的号码，如果这样的号码不唯一，就找最小的号码，想到用哈希表进行存储。

代码如下：

 //本题采用除留取余法构造哈希函数，使用分离链表法解决冲突

 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <iostream>

 using namespace std;
 #define KEYLENGTH 11                   /* 关键词字符串的最大长度 */
 typedef char ElementType[KEYLENGTH+]; /* 关键词类型用字符串 */
 typedef int Index;                     /* 散列地址类型 */

 #define MAXTABLESIZE 1000000

 typedef struct LNode *PtrToLNode;
 struct LNode
 {
     ElementType Data;
     PtrToLNode Next;
     int cnt;
 };
 typedef PtrToLNode Position;
 typedef PtrToLNode List;

 typedef struct TblNode *HashTable; /* 散列表类型 */
 struct TblNode     /* 散列表结点定义 */
 {
     int TableSize; /* 表的最大长度 */
     List Heads;    /* 指向链表头结点的数组 */
 };

 Index Hash(int k, int TableSize )  //哈希函数
 {
     return k%TableSize; //除留取余法
 }

 int nextPrime(int n)  //选取一个产生冲突较少的素数，作为表长
 {
     int j=n%?n+:n+;
     while(j<=MAXTABLESIZE)
     {
         int i=;
         for(i=; i*i<=j; i++)
         {
             if(!(j%i))
                 break;
         }
         if(i*i>j)
             return j;
         else
             j+=;   //素数每次加2，减少循环次数
     }
 }
 Position Find(HashTable h,ElementType key,Index k)
 {
     Position p=h->Heads[k].Next;
     while(p&&strcmp(key,p->Data))
     {
         p=p->Next;
     }
     return p;
 }
 void insert(HashTable h,ElementType key)
 {
     int sum=;
     for(int i=; i<; i++)
     {
         sum=sum*+(key[i]-'');   //以第七位到第11位的元素进行哈希
     }
     Index k=Hash(sum,h->TableSize);
     Position p=Find(h,key,k);
     if(!p)
     {
         //使用头插法，提高算法效率
         Position newPtr=(Position)malloc(sizeof(LNode));
         strcpy(newPtr->Data,key);
         newPtr->Next=NULL;
         newPtr->cnt=;
         newPtr->Next=h->Heads[k].Next;
         h->Heads[k].Next=newPtr;

     }
     else
         p->cnt++;
 }
 HashTable BuildTable(int m)
 {

     HashTable h;
     h=(HashTable)malloc(sizeof(TblNode));
     //cout<<"111111111111"<<endl;
     h->TableSize=nextPrime(m);
     h->Heads=(List)malloc(sizeof(LNode)*h->TableSize);

     for(int i=; i<h->TableSize; i++)
     {
         h->Heads[i].Next=NULL;
         h->Heads[i].cnt=;
     }
     return h;
 }

 int main()
 {
     int n,m;
     scanf("%d",&n);
     m=*n;
     ElementType key;
     HashTable h=BuildTable(m);
     while(m--)
     {
         scanf("%s",key);
         insert(h,key);
     }
     //cout<<"111111111111"<<endl;
     int maxnum=;
     int ans=;
     for(int i=; i<h->TableSize; i++)
     {
         Position p=h->Heads[i].Next;
         while(p)
         {
             if(p->cnt>maxnum)
             {
                 maxnum=p->cnt;
                 strcpy(key,p->Data);
                 ans=;
             }
             else if(p->cnt==maxnum)
             {
                 ans++;
                 if(strcmp(key,p->Data)>)
                     strcpy(key,p->Data);
             }
             p=p->Next;
         }
         //cout<<"111111111111"<<endl;
     }
     //cout<<"111111111111"<<endl;
     printf("%s %d",key,maxnum);
     if(ans>)
         printf(" %d",ans);
     printf("\n");
     return ;
 }

 /*
 4
 13005711862 13588625832
 13005711862 13088625832
 13588625832 18087925832
 13005711862 13588625832

 */

坚持不懈地努力才能成为大神！