11-散列1 电话聊天狂人 (25分) (2020浙大Mooc数据结构配套题)

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

输入格式:

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

输出格式:

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

输入样例:

4
13005711862 13588625832
13505711862 13088625832
13588625832 18087925832
15005713862 13588625832

输出样例:

13588625832 3

  消除恐惧的最好办法就是面对恐惧。从模板照抄开始写起补缺补漏,理解思路后反复多刷,熟练后再自己慢慢简化,要是上来就自己架构,基础不扎实很有可能写了一大堆,修修改改最后还是变成了别人的模样,还改不对。

示例代码:

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

#define MAXTABLESIZE 100000 /* 允许开辟的最大散列表长度 */
#define KEYLENGTH 11                   /* 关键词字符串的最大长度 */
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 enum {false, true} bool;
typedef struct TblNode *HashTable; /* 散列表类型 */
struct TblNode {   /* 散列表结点定义 */
    int TableSize; /* 表的最大长度 */
    List Heads;    /* 指向链表头结点的数组 */
};



int NextPrime( int N );
void DestroyTable( HashTable H );
HashTable CreateTable( int TableSize );
bool Insert( HashTable H, ElementType Key );
Index Hash( HashTable H, ElementType Key );
Position Find( HashTable H, ElementType Key );
void ScanAndOutput( HashTable H );

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);
	DestroyTable(H);
}

HashTable CreateTable( int TableSize )
{
    HashTable H;
    int i;
 
    H = (HashTable)malloc(sizeof(struct TblNode));
    /* 保证散列表最大长度是素数，具体见代码5.3 */
    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;
    }
 
    return H;
}
 
Position Find( HashTable H, ElementType Key )
{
    Position P;
    Index Pos;
     
    Pos = Hash( H, Key ); /* 初始散列位置 */
    P = H->Heads[Pos].Next; /* 从该链表的第1个结点开始 */
    /* 当未到表尾，并且Key未找到时 */ 
    while( P && strcmp(P->Data, Key) )
        P = P->Next;
 
    return P; /* 此时P或者指向找到的结点，或者为NULL */
}

Index Hash( HashTable H, ElementType Key )
{
	int n;
	n = ( (Key[6]-'0')*10000 + (Key[7]-'0')*1000 +
	      (Key[8]-'0')*100 + (Key[9]-'0')*10 + 
  	 	  (Key[10]-'0')*1 ) % H->TableSize;
  	return n;
}

bool 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);
        NewCell->Count = 1;
        Pos = Hash( H , Key ); /* 初始散列位置 */
        /* 将NewCell插入为H->Heads[Pos]链表的第1个结点 */
        NewCell->Next = H->Heads[Pos].Next;
        H->Heads[Pos].Next = NewCell; 
        return true;
    }
    else { /* 关键词已存在 */
        P->Count++;
        return false;
    }
}
 
void DestroyTable( HashTable H )
{
    int i;
    Position P, Tmp;
     
    /* 释放每个链表的结点 */
    for( i=0; i<H->TableSize; i++ ) {
        P = H->Heads[i].Next;
        while( P ) {
            Tmp = P->Next;
            free( P );
            P = Tmp;
        }
    }
    free( H->Heads ); /* 释放头结点数组 */
    free( H );        /* 释放散列表结点 */
}

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;
}

void ScanAndOutput( HashTable H )
{
	int i,MaxCount = 0,PCount = 0;
	List Ptr;
	ElementType MinPhone;
	MinPhone[0] = '\0';
	for(i = 0; i < H->TableSize; i++){
		Ptr = H->Heads[i].Next;
		while(Ptr != NULL){
			if(Ptr->Count > MaxCount){
				MaxCount = Ptr->Count;
				strcpy(MinPhone,Ptr->Data);
				PCount = 1;
			}else if(Ptr->Count == MaxCount){
				PCount++;
				if(strcmp(MinPhone,Ptr->Data) > 0){
					strcpy(MinPhone,Ptr->Data);
				}
			}
			Ptr = Ptr->Next;
		}
	}
	printf("%s %d",MinPhone,MaxCount);
	if(PCount > 1) printf(" %d",PCount);
	printf("\n");
	return;
}