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

输入格式:

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

输出格式:

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

输入样例:

4

13005711862 13588625832

13505711862 13088625832

13588625832 18087925832

15005713862 13588625832

输出样例:

13588625832 3

#include<iostream>

#include<algorithm>

#include<string>

using namespace std;

typedef long long LL;

typedef struct Treenode

{

    LL str;

    int cnt;

    struct Treenode* left;

    struct Treenode* right;

}Treenode,*Tree;

Tree Newnode(LL s)

{

    Tree t = (Tree)malloc(sizeof(Treenode));

    t->str = s;

    t->cnt = ;

    t->left = NULL;

    t->right = NULL;

    return t;

}

Tree Insert(Tree T,LL s)

{

    if(!T)

        T = Newnode(s);

    else if(T->str>s)

        T->left = Insert(T->left,s);

    else if(T->str<s)

        T->right = Insert(T->right,s);

    else

        T->cnt = T->cnt+;

    return T;

}

void find(Tree T,LL &mins,int &maxt,int &same)

{

    if(T)

    {

        if(T->cnt > maxt)

        {

            maxt = T->cnt;

            mins = T->str;

            same = ;

        }

        else if((T->cnt==maxt))

        {

            if(T->str<mins)

                mins = T->str;

            same++;

        }

        find(T->left,mins,maxt,same);

        find(T->right,mins,maxt,same);

    }

}

int main()

{

    int n;

    LL t1;

    Tree T;

    cin>>n;

    cin>>t1;

    T =Newnode(t1);

    for(int i=;i<*n;i++)

    {

        cin>>t1;

        T = Insert(T,t1);

    }

    LL ms=;

    int mt=,num=;

    find(T,ms,mt,num);

    cout<<ms<<' '<<mt;

    if(num>)

        cout<<' '<<num<<endl;

    else

        cout<<endl;

    return ;

}

#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<iostream>

using namespace std;

/*
Hash表的使用方法//hash表size一般是大于N的第一个素数
1.嵌套定义结构体 注意在hashtable 中定义的是一个指向指针的指针（指向list结构体的指针列表）
初始化时注意分配空间！
所以在给Hshlist分配空间的时候，要注意，(list*)malloc(sizeof(list))这样才对！
2.确定hash函数，在这里使用atoi把字符串转变为数字然后对哈希表size取余数.
3.插入操作，查找操作
列表元素第一个是头节点，应该从它的next元素开始遍历
通过hash函数找到对应的在list中的位置，然后在该位置中查找元素，如果存在就计数，不存在就在列表头
加入元素.
4.destroy操作，分别对应Init一一释放空间
*/

typedef struct Listnode *Pos;

typedef struct Listnode

{

    char Phonenum[];

    int cnt;

    Pos next;

}*List;

typedef struct Hashtable

{

    int tablesize;

    List *Thelist;

} *HashTable;

int Hash(int key,int size)

{

    return key%size;

}

void Insert(char key[],HashTable H);

Pos Find(char key[],HashTable H);

HashTable Init(int size);

void destroy(HashTable H);

void FindMax(HashTable H);

int NextPrime(int x);

int main()

{

    int n;

    scanf("%d",&n);

    HashTable H = Init(*n);

    char from[],to[];

    for(int i=;i<n;i++)

    {

        scanf("%s%s",from,to);

        Insert(from,H);

        Insert(to,H);

    }

    FindMax(H);

    destroy(H);

}

int NextPrime(int x)

{

    int i,j;

    for(i=x;;i++)

    {

        for(j=;j*j<=i;j++)

            if(i%j==)

                break;

        if(j*j>i)

            return i;

    }

}

HashTable Init(int size)

{

    int Tsize = NextPrime(size);

    HashTable H = (HashTable)malloc(sizeof(Hashtable));

    H->tablesize = Tsize;

    H->Thelist = (List*)malloc(sizeof(List)*Tsize);

    for(int i=;i<Tsize;i++)

    {

        H->Thelist[i] = (List)malloc(sizeof(Listnode));

        H->Thelist[i]->next = NULL;

    }

    return H;

}

void Insert(char key[],HashTable H)

{

    Pos p,tmp;

    List t = H->Thelist[Hash(atoi(key+),H->tablesize)];

    p = Find(key,H);

    if(p==NULL)

    {

        tmp = (List)malloc(sizeof(Listnode));

        tmp->cnt = ;

        strcpy(tmp->Phonenum,key);

        tmp->next = t->next;

        t->next = tmp;

    }

    else

        (p->cnt)++;

}

Pos Find(char key[],HashTable H)

{

    List t = H->Thelist[Hash(atoi(key+),H->tablesize)];

    List p = t->next;

    while(p!=NULL&&strcmp(p->Phonenum,key))

        p = p->next;

    return p;

}

void destroy(HashTable H)

{

    for(int i=;i< H->tablesize;i++)

    {

        free(H->Thelist[i]);

    }

    free(H->Thelist);

    free(H);

}

void FindMax(HashTable H)

{

    char MinPhone[];

    int max = -,same = ;

    for(int i=;i<H->tablesize;i++)

    {

        List t = H->Thelist[i];

        t = t->next;

        while(t!=NULL)

        {

            if( t->cnt > max)

            {

                max = t->cnt;

                strcpy(MinPhone,t->Phonenum);

                same = ;

            }

            else if(t->cnt == max)

            {

                if(strcmp(MinPhone,t->Phonenum)>)

                    strcpy(MinPhone,t->Phonenum);

                same++;

            }

            t =t->next;

        }

    }

    printf("%s %d", MinPhone, max);

    if (same > )

        printf(" %d", same);

}