7-14 电话聊天狂人 (25分)

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

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

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

4
13005711862 13588625832
13505711862 13088625832
13588625832 18087925832
15005713862 13588625832

输出样例:

13588625832 3

代码来自中国MOOC 浙江大学数据结构课程

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<stdbool.h>
#define KEYLENGTH 11
#define MAXTABLESIZE 100000
#define MAXD 5

typedef char ElementType[KEYLENGTH+1];
typedef int Index;
//用链表分离法处理冲突，故定义链表结点储存散列表单元类型
typedef struct LNode *PtrToLNode;
struct LNode{
    ElementType Data;	//储存元素
    PtrToLNode Next;
    int Count;	//记录号码出现次数
};
typedef PtrToLNode Position;
typedef PtrToLNode List;
/*   定义散列表的数据结构   */
typedef struct TblNode *HashTable;
struct TblNode{
    int TableSize;	//表的最大长度
    List Heads;		//储存散列表单元类型的结构数组
};
/* 选取大于N小于MAXTABLESIZE的素数作为散列表长度，选取素数可以使散列分布更均匀*/
int NextPrime(int N){
    int i,P = (N%2)?N+2:N+1;	//P为大于N的奇数
/* 寻找大于等于P小于等于MAXTABLESIZE的素数 */
    while(P<=MAXTABLESIZE){
        for(i=(int)sqrt(P);i>2;i--)
            if(!(P%i))    break;
        if(i==2)    break;	//找到范围内第一个素数，跳出while循环
        else    P+=2;
    }
    return P;	
}
/*    构造散列函数    */
int Hash (int Key, int P){
    
    return Key%P;	//取key 的后 P位
}
/*  散列表初始化函数   */
HashTable CreateTable (int TableSize){
    HashTable H;
    int i;
    H = (HashTable)malloc(sizeof(struct TblNode));
    H->TableSize = NextPrime(TableSize);	
    /*  开辟数组空间存储散列表单元元素   */
    H->Heads = (List)malloc(H->TableSize*sizeof(struct LNode));
    /*  初始化数组元素  */
    for(i=0;i<H->TableSize;i++){
        H->Heads[i].Data[0] = '\0';
        H->Heads[i].Next = NULL;
        H->Heads[i].Count = 0;
    }
    return H;
}
/*  查找函数  */
Position Find (HashTable H,ElementType Key){
    Position P;
    Index Pos;	//地址元素，储存数组下标
    /*  atoi函数把数字字符转换成数值  */
    /*  通过Hash 函数把atoi函数处理过的数据Key转化为地址（即数组下标)  */
    Pos = Hash(atoi(Key+KEYLENGTH-MAXD),H->TableSize);
/*  每一个H->heads[i]都视为头结点，不储存值，依次比较H->heads[i]指向的值，若有相同值则返回该结点，否则返回NULL  */
    P = H->Heads[Pos].Next;
    while(P&&strcmp(P->Data,Key))
        P = P->Next;
    
    return P;
}
/*  插入函数  */
bool Insert(HashTable H,ElementType Key){
    Position P,NewCell;
    Index Pos;
    
    P = Find(H,Key);
/*  若P为NULL，表示Key没出现过，将其插入对应的H->Heads[Pos] 中  */
    if(!P){
    /*  分配存储空间并赋值   */
        NewCell = (Position)malloc(sizeof(struct LNode));
        strcpy(NewCell->Data,Key);
        NewCell->Count = 1;
    /*   找到储存地址并插入对应的H->Heads[Pos] 中   */
        Pos = Hash(atoi(Key+KEYLENGTH-MAXD), H->TableSize);
        NewCell->Next = H->Heads[Pos].Next;
        H->Heads[Pos].Next = NewCell;
        return true;
    }else{		//Key 已经出现过，出现次数加一
        P->Count++;
        return false;
    }
}
/*   寻找最小号码并输出   */
void ScanAndOutput(HashTable H){
    int i,MaxCnt,Pcnt;
    MaxCnt = Pcnt = 0;//MaxCnt 记录一个号码最大出现次数， Pcnt记录与MaxCnt出现次数相同的号码数
    ElementType MinPhone;	//存储最小号码
    List Ptr;
    MinPhone[0] = '\0';
    /*  遍历散列表进行比较  */
    for(i=0;i<H->TableSize;i++){
        Ptr = H->Heads[i].Next;
        while(Ptr){		//Ptr非空，即储存有元素时
      /*  当前号码出现次数大于最大出现次数时，更新最大出现次数和最小号码  */
            if(Ptr->Count>MaxCnt){
                MaxCnt = Ptr->Count;
                strcpy(MinPhone,Ptr->Data);
                Pcnt = 1;	//出现MaxCnt 次的号码只有一个
            }else if(Ptr->Count==MaxCnt){	//当前号码出现次数大于最大出现次数时
                Pcnt++;		//出现MaxCnt 次的号码数加一
       /*  若当前号码小于之前的最小号码，更新最小号码  */
                if(strcmp(MinPhone,Ptr->Data)>0)
                    strcpy(MinPhone,Ptr->Data);
            }
            Ptr = Ptr->Next;	//比较下一个元素
        }
    }
    printf("%s %d",MinPhone,MaxCnt);
    if(Pcnt>1)		//最大出现次数号码不唯一时输出
        printf(" %d",Pcnt);
    printf("\n");
}

int main(void){
    int N,i;
    ElementType Key;
    HashTable H;
    
    scanf("%d",&N);
    H = CreateTable(N*2);
    for(i=0;i<N;i++){
        scanf("%s",Key);
        Insert(H,Key);
        scanf("%s",Key);
        Insert(H,Key);
    }
    ScanAndOutput (H);
    
    return 0;
}

个人水平有限，仅添加了些注释，希望能方便理解