数据结构与算法——7-14 电话聊天狂人 (25分)

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

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

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

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

思路：采用散列（哈希）表查找，散列技术是在记录的存储位置和他的关键字之间建立一个确定的对应关系f,使得每个关键字key对应一个存储位置f(key)
这种对应关系f称为散列函数，又称哈希（hash)函数
采用散列技术将记录存储在一块连续的存储空间中，这块连续的存储空间称为散列表或哈希表（hash table)
明确好定义后，第一就是散列函数的构造，这里采用除留余数法

int Hash ( int Key, int P )
{ /* 除留余数法法散列函数 */
    return Key%P;
}

然后建立哈希表createTable,然后依次输入，进行find()查找，如果没有就进行insert操作,插入到第一个结点，如果有 计数count++,建立好散列表过后，进行扫描，不断更新maxcnt的值和计数狂人是否不唯一

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>

#define KEYLENGTH 11 /* 关键词字符串的最大长度 */
#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; /* 指向链表头结点的数组 */
};
#define MAXTABLESIZE 1000000

int Hash ( int Key, int P )
{ /* 除留余数法法散列函数 */
    return Key%P;
}

int NextPrime( int N )
{ 
    /* 返回大于N且不超过MAXTABLESIZE的最小素数 */
    int i, p = (N%2)? N+2 : N+1; /*从大于N的下一个奇数开始 */
    while( p <= MAXTABLESIZE ) 
    {
        for( i=(int)sqrt(p); i>2; i-- )
            if ( !(p%i) ) 
                break; /* p不是素数 */
        if ( i==2 ) break; /* for正常结束，说明p是素数 */
        else p += 2; /* 否则试探下一个奇数 */
    }
    return 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;
    /* 初始散列位置 */
    Pos = Hash(atoi(Key+KEYLENGTH-MAXD), H->TableSize);
    P = H->Heads[Pos].Next; /* 从该链表的第1个结点开始 */
    /* 当未到表尾，并且Key未找到时 */
    while( P && strcmp(P->Data, Key) )
        P = P->Next;
    return P; /* 此时P或者指向找到的结点，或者为NULL */
}

int Insert( HashTable H, ElementType Key )
{ 
    Position P, NewCell;
    Index Pos;
    P = Find( H, Key );
    
    if ( !P ) 
    { /* 关键词未找到，可以插入 */
        NewCell = (Position)malloc(sizeof(struct LNode));
        strcpy(NewCell->Data, Key);//将key的值复制到NewCell->Data
        
        /* 初始散列位置 */
        NewCell->Count = 1;
        Pos = Hash(atoi(Key+KEYLENGTH-MAXD), H->TableSize);
        
        /*将NewCell插入为H->Heads[Pos]链表的第1个结点 */
        NewCell->Next = H->Heads[Pos].Next;
        H->Heads[Pos].Next = NewCell;
        return 1;//true
    }
    else { 
        /* 关键词已存在 */
        P->Count++;
        return 0;//false
        }
}

void ScanAndOutput( HashTable H )
{ 
    int i;
    int MaxCnt = 0,PCnt = 0;
    ElementType MinPhone;
    List Ptr;
    MinPhone[0] = '\0';
    for (i=0; i<H->TableSize; i++) 
    { /* 扫描链表 */
        Ptr = H->Heads[i].Next;
        while (Ptr) 
        {
            if (Ptr->Count > MaxCnt) 
            { /* 更新最大通话次数 */
                MaxCnt = Ptr->Count;
                strcpy(MinPhone, Ptr->Data);
                PCnt = 1;
            }
            else if (Ptr->Count == MaxCnt) 
            {
                PCnt ++; /* 狂人计数 */
                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()
{ 
    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;
    }