11-散列1 电话聊天狂人 (25 分)

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

输入格式:

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

输出格式:

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

输入样例:

4
13005711862 13588625832
13505711862 13088625832
13588625832 18087925832
15005713862 13588625832

输出样例:

13588625832 3

//2，3测试点未过
#include<iostream>
#include<map>
using namespace std;
const int maxn = 1000100;

int main(){
    int n;
    //scanf("%d",&n);
    cin >> n;
    map<string,int> mp; 
    string s1,s2;
    for(int i = 0; i < n; i++){
        cin >> s1 >> s2;
        ++mp[s1];
        ++mp[s2];
    }
    int cnt = 0;//通话最多次人数
     int time = -1;//通话最多次的时间
     string s;//通话最多次最小标号 
    map<string,int>::iterator it;
    
    
    for(it = mp.begin(); it != mp.end(); it++){
        if(it->second > time){
            cnt = 1;
            time = it->second;
            s = it->first;
        }else if(it->second == time){
              cnt++;
              if(s < it->first) s= it->first;
        }
    }
    cout << s << " " << time;
    if(cnt > 1) cout << " " << cnt << endl;
    return 0;
}

https://blog.csdn.net/xijujie/article/details/53224218

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 12
 
typedef struct ListNode *Position;
typedef struct HTable *HashTable;
struct ListNode {
    char data[N];
    int count;
    Position next;
};
struct HTable {
    Position list;
    int size;
};
HashTable CreatTable(int n);
void Insert(HashTable H, char *key);
void Solve(HashTable H);
int NextPrime(int n);
 
int main() {
    int i, n;
    char key[N];
    HashTable H;
    scanf("%d", &n);
    H = CreatTable(n * 2);
    for (i = 0; i < 2 * n; i++) {
        scanf("%s", key);
        Insert(H, key);
    }
    Solve(H);
    return 0;
}
 
HashTable CreatTable(int n) {
    HashTable H;
    int i;
    H = (HashTable)malloc(sizeof(struct HTable));
    H->size = NextPrime(n);
    H->list = (Position)malloc(H->size*sizeof(struct ListNode));
    for (i = 0; i < H->size; i++) 
        H->list[i].next = NULL;    
    return H;
}
 
void Insert(HashTable H, char *key) {
    Position p, temp;
    int h;
    h = (atoi(key + 6)) % H->size;
    p = H->list[h].next;
    while (p && strcmp(p->data, key)) {
        p = p->next;
    }
    if (p) p->count++;
    else {
        temp = (Position)malloc(sizeof(struct ListNode));
        strcpy(temp->data, key);
        temp->count = 1;
        temp->next = H->list[h].next;
        H->list[h].next = temp;
    }
}
 
 
void Solve(HashTable H) {
    int i, max = 0, num;
    char min[N];
    Position p;
    for (i = 0; i < H->size; i++) {
        p = H->list[i].next;
        while (p) {
            if (p->count > max) {
                max = p->count;
                strcpy(min, p->data);
                num = 1;
            }
            else if (p->count == max) {
                num++;
                if (strcmp(p->data, min) < 0)
                    strcpy(min, p->data);
            }
            p = p->next;
        }
    }
 
    if(num == 1)
        printf("%s %d\n", min, max);
    else
        printf("%s %d %d\n", min, max, num);
    
}
 
int NextPrime(int n) {
    int i, j;
    n = (n % 2) ? n + 2 : n + 1;
    for (i = n;; i += 2) {
        for (j = 3; j*j <= i && i%j; j++);
        if (j*j > i) break;
    }
    return i;
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
 
#define MAXS 11
#define MAXD 5
 
typedef struct HashEntry *List;
struct HashEntry{
    char PhoneNo[MAXS+1];
    int Cnt;
    List Next;
};
 
struct HashTb1{
    int TableSize;
    List TheLists;
};
typedef struct HashTb1 *HashTable;
 
int NextPrime(int N){
    int i;
    if(!(N%2))N++;
    for(;;N+=2){
        for(i=(int)sqrt(N);i>2;i--){
            if(!(N%i))break;
        }
        if(i==2)break;
    }
    return N;
}
 
HashTable InitializeTable(int N){
    int i;
    HashTable H=(HashTable)malloc(sizeof(struct HashTb1));
    H->TableSize=NextPrime(N);
    H->TheLists=(List)malloc(sizeof(struct HashEntry)*H->TableSize);
    for(i=0;i<H->TableSize;i++){
        H->TheLists[i].Cnt=0;
        H->TheLists[i].Next=NULL;
        H->TheLists[i].PhoneNo[0]='\0';
    }
    return H;
}
 
int Hash(int Key,int P){
    return Key%P;
}
 
void InsertAndCount(char *Key,HashTable H){
    List Ptr,NewCell,L;
    L=&(H->TheLists[Hash(atoi(Key+6),H->TableSize)]);
    Ptr=L->Next;
    while(Ptr&&strcmp(Ptr->PhoneNo,Key)){
        Ptr=Ptr->Next;
    }
    if(Ptr){
        Ptr->Cnt++;    
    }
    else{
        NewCell=(List)malloc(sizeof(struct HashEntry));
        strcpy(NewCell->PhoneNo,Key);
        NewCell->Cnt=1;
        NewCell->Next=L->Next;
        L->Next=NewCell; 
    }
}
 
void Output(HashTable H){
    int i,MaxCnt,PCnt;
    List Ptr;
    char MinPhone[MAXS+1];
    MaxCnt=PCnt=0;
    MinPhone[0]='\0';
    for(i=0;i<H->TableSize;i++){
        Ptr=H->TheLists[i].Next;
        while(Ptr){
            if(Ptr->Cnt>MaxCnt){
                MaxCnt=Ptr->Cnt;
                strcpy(MinPhone,Ptr->PhoneNo);
                PCnt=1;
            }
            else if(Ptr->Cnt==MaxCnt){
                PCnt++;
                if(strcmp(MinPhone,Ptr->PhoneNo)>0){
                    strcpy(MinPhone,Ptr->PhoneNo);
                }
            }
            Ptr=Ptr->Next;
        }
    }
    printf("%s %d",MinPhone,MaxCnt);
    if(PCnt>1){
        printf(" %d",PCnt);
    }
//    printf("\n");
}
int main(){
    int N,i;
    char Key[MAXS+1];
    HashTable H;
    scanf("%d",&N);
    H=InitializeTable(N);
    for(i=0;i<N;i++){
        scanf("%s",Key);
        InsertAndCount(Key,H);
        scanf("%s",Key);
        InsertAndCount(Key,H);
    }
    Output(H);    
} 

这道题留着等九月份再看把