小白专场：电话聊天狂人

最新推荐文章于 2021-02-23 20:47:15 发布

-出发-

最新推荐文章于 2021-02-23 20:47:15 发布

阅读量817

点赞数

分类专栏：数据结构数据结构心法指南

本文链接：https://blog.csdn.net/happyjacob/article/details/84932013

版权

数据结构同时被 2 个专栏收录

39 篇文章 7 订阅

订阅专栏

数据结构心法指南

39 篇文章 9 订阅

订阅专栏

题目：

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

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

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

输入样例:
4
13005711862 13588625832
13505711862 13088625832
13588625832 18087925832
15005713862 13588625832
输出样例:
13588625832 3

解法1 – 排序

第1步：读入最多2105个电话号码，每个号码存为长度
为11的字符串
第2步：按字符串非递减顺序排序
第3步：扫描有序数组，累计同号码出现的次数，并且
更新最大次数

这种方法优点是编程简单快捷，缺点是无法拓展解决动态插入的问题
虽说方法不太好，但是程序自己敲一下还是挺好的。直接上代码。

代码中有几处需要说明，电话号码太长了，为了不想输入，直接构造了数组，想自己构造的，注释已构造的数组，把我注释的构造数组的代码取消注释，试一试；11位的数字只能用unsigned long long来表示了；这段代码有一个很大的弊端，在主循环中最后一个通话次数没有和前面的聊天狂人作比较，来决定电话狂人是不是最后一个人，所以在退出循环之后把最后一个人单拿出来作比较，代码有重复使用，有更好的方法，欢迎留言哦！

#include<iostream>
#include <algorithm>
using namespace std;
typedef unsigned long long ElementType;

int main()
{
	int n;
	ElementType fir, sec, key;	//一前一后两个元素
	ElementType madman;		//聊天狂人电话号码
	//chatnum：当前电话号码聊天次数，maxchatnum:聊天狂人聊天次数
	//peoplenum：和聊天狂人有相同聊天次数的一共多少人
	int chatnum = 0, maxchatnum = 0, peoplenum = 0;

//	cin >> n;
	n = 4;
	ElementType a[] = { 13005711862, 13588625832, 13505711862, 13088625832, 
	13588625832, 18087925832, 15005713862, 13588625832 };//输电话太麻烦了，直接传进来
	/*
	ElementType *a = new ElementType[2*n];
	for (int i = 0; i<n; i++)
	{
		cin >> key;
		a[2 * i] = key;
		cin >> key;
		a[2 * i + 1] = key;
	}
	*/
	sort(a, a + 2*n);		//对电话号码进行排序
	/*
	for (int i = 0; i < 2 * n; i++)//展示排序后的结果
		cout << a[i] << " ";
	cout << endl;
	*/
	fir = sec = a[0];
	chatnum = 1; peoplenum = 1;

	for (int i = 1; i < 2*n; i++)	//对排好序的电话进行扫描
	{
		sec = fir; fir = a[i];	//前进一步
		if (fir == sec)		//还是同一个电话，聊天次数加1
			chatnum++;
		else			//上面那个人只有这么多通话，换人啦
		{

			if (chatnum > maxchatnum)	//这个人比聊天狂人还能聊，荣登宝冠
			{
				madman = sec;		//更新聊天狂人
				maxchatnum = chatnum;	//更新聊天狂人的聊天次数

				peoplenum = 1;		//干掉了聊天狂人，就他一个这么能聊
			}

			else if (chatnum == maxchatnum)//两个人旗鼓相当，聊天次数一样
			{
				if (sec < madman)	//谁的电话号码数字小，谁是狂人
					madman = sec;
				peoplenum++;		//和狂人一样能聊的加人1
			}
			chatnum = 1;//每次换人，这个人聊天次数从1开始计数
		}
//		cout << i << "聊天次数" << chatnum << endl;//展示统计过程
	}

	//退出循环，判断最后一个人的通话次数
	if (chatnum > maxchatnum)
	{
		madman = sec;
		maxchatnum = chatnum;
		peoplenum = 1;
	}

	else if (chatnum == maxchatnum)
	{
		if (sec < madman)
			madman = fir;
		peoplenum++;
	}
	cout << madman << " " << maxchatnum << " ";
	if (peoplenum>1)
		cout << peoplenum << endl;
	return 0;
}

解法2 – 直接映射

第1步：创建有2×10¹⁰个单元的整数数组，保证每个电话
号码对应唯一的单元下标；数组初始化为0
第2步：对读入的每个电话号码，找到以之为下标的单
元，数值累计1次
第3步：顺序扫描数组，找出累计次数最多的单元

为什么是2×10¹⁰呢，因为电话号码是11位，目前第一位都是1，取2×10¹⁰个单元的数组足够对应所有的电话号码。扫描数组时，对应的下标就是对应的电话。
优点：编程简单快捷，动态插入快

缺点：下标超过了unsigned long
需要2×10¹⁰×2 byte≈37GB
为了2×10⁵个号码扫描2×10¹⁰个单元（在我们的问题里，最多只有2×10⁵个电话号码，却又2×10¹⁰个单元）

解法3 – 带智商的散列

前面的方法都不太好，重点终于来了。
电话号码的组成如下：我们取后面5位作为哈希表的关键值
在这里插入图片描述
这里采用分离链接法来组织哈希表。

P表示有多少个链表，P后面的指针指向第一个链表头节点。

程序框架搭建

int main()
{
	创建散列表;
	读入号码插入表中;
	扫描表输出狂人;
	return 0;
}

将上面的框架转化成代码，就是如下代码

int main()
{
	int N, i;
	ElementType Key;
	HashTable H;
	cin>>N;
	H = CreateTable(N * 2); /* 创建一个散列表*/
	for (i = 0; i<N; i++)
	{
		cin>>Key; Insert(H, Key);
		cin>>Key; Insert(H, Key);
	}
	ScanAndOutput(H);
	DestroyTable(H);
	return 0;
}

要实现哈希表的创建，需要的功能如下：

需要定义哈希表的结构，哈希表中链表的结构；
要创建空的哈希表，需要求出大与N的最小素数，然后创新空哈希表；
要实现在哈希表中插入元素，需要给出哈希函数，算出哈希值，并根据哈希值查找插入的位置。

ScanAndOutput(H)函数：
扫描整个散列表；
更新最大通话次数；
更新最小号码+ 统计人数。

完整代码如下：

#define _CRT_SECURE_NO_DEPRECATE
#include<iostream>
using namespace std;

#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 struct TblNode {	//散列表结点定义
	int TableSize;		//表的最大长度
	List Heads;		//指向链表头结点的数组
}*HashTable;

#define MAXTABLESIZE 1000000
//返回大于N且不超过MAXTABLESIZE的最小素数
int NextPrime(int N)
{
	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;
}

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

#define MAXD 5
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
}

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(atoi(Key+KEYLENGTH-MAXD), H->TableSize);
		
		NewCell->Next = H->Heads[Pos].Next;//将NewCell插入为H->Heads[Pos]链表的第1个结点
		H->Heads[Pos].Next = NewCell;
		return true;
	}
	else //关键词已存在
	{
		P->Count++;
		return false;
	}
}

void ScanAndOutput(HashTable H)
{
	int i, 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;
		}
	}
	cout << MinPhone << " " << MaxCnt;
	if (PCnt > 1)
		cout << PCnt<<endl;
}

int main()
{
	int N, i;
	ElementType Key;
	HashTable H;
	cin>>N;
	H = CreateTable(N * 2); //创建一个散列表
	for (i = 0; i<N; i++)
	{
		cin>>Key ; Insert(H, Key);
		cin>>Key; Insert(H, Key);
	}
	ScanAndOutput(H);
//	DestroyTable(H);
	return 0;
}