精华内容
下载资源
问答
  • 含需求分析、概要设计、详细设计、调试分析、使用说明、测试结果、附件。...待填入哈希表的人名共有30个,取平均查找长度的上限为2。哈希函数用除留余数法构造,用线性探测再散列法或链地址法处理冲突。
  • 哈希表课程设计数据结构实验报告——哈希表设计 针对某个集体中的人名设计一个哈希表,使得平均查找长度不超过R,完成相应的建立和查表程序. 1.2 人名为汉语拼音形式,最长不超过18个字符(如:庄双双 ...
  • 1/2/2020 数据结构实验报告2 - 百度文库 电子信息工程学院 级 数据结构实验报告 电子信息工程学院2014 级 数据结构实验报告 2014 网页 资讯 视频 图片 知道 文库 贴吧 采购 地图 | 百度首页 登录 VIP新客立减2元 ...
  • 这是我们数据结构哈希表实验报告,是严格按照实验报告格式来的,自己做的,希望能帮到你
  • 福 建 工 程 学 院 课 程 设 计 课程 题目 专业 班级 座号 姓名 算法与数据结构 哈希表 网络工程 xxxxxx 班 xxxxxxxxxxxx xxxxxxx 2011 年 12 月 31 日 实验题目哈希表 一 要解决的问题 针对同班同学信息设计一个...
  • 洛阳理工学院实验报告 系部 计算机与信息工程系 班级 学号 姓名 课程名称 数据结构 实验日期 2014.4.23 实验名称 实验5图的遍历的实现 成绩 实验目的 掌握图的邻接矩阵和邻接两种存储结构掌握图的深度优先和广度...
  • 课题的目的和任务:根据数据元素的关键字和哈希函数建立哈希表并初始化哈希表,用开放定址法处理冲突,按屏幕输出的功能表选择所需的功能实现用哈希表数据元素的插入,显示,查找,删除。
  • 哈希表设计程序设计+数据结构实验报告 1.1 针对某个集体中的人名设计一个哈希表,使得平均查找长度不超过R,完成相应的建立和查表程序. 1.2 人名为汉语拼音形式,最长不超过18个字符(如:庄双双 zhuangshuangshuang)...
  • 数据结构哈希表实验报告 构造二叉树,构造哈希表等 c语言版
  • 淮海工学院计算机科学系 实 验 报 告 书 课程名 数据结构 题 目 线性数据结构试验 班 级 软嵌 151 学 号 2015123352 姓 名 韩吉 评语 成绩 指导教师 批阅时间 年 月 日 数据结构 实验报告 - 1 - 线性表实验报告要求 ...
  • 大家程序还是要自己写啊 这次考试考了三十分程序设计,结构大多不会
  • 兰 州 交 通 大 学 兰 州 交 通 大 学 数据结构与算法 数据结构与算法课程设计 姓 名 姓 名 张正邦 学 号 201408330 班 级 地信1401班 专 业 地理信息科学 学 院 测地学院 任课教师 杜 萍 2015年12月28日 2015年12月...
  • 任务要求:针对姓名信息进行初始化哈希表,可以进行显示哈希表,查找元素。 设计思想:哈希函数用除留余数法构造,用线性探测再散列处理冲突。 设人名为中国人姓名的汉语拼音的形式,有30个待入的人名,取平均查找...
  • . 教育资料 HUNAN 课程实习报告 题 目 哈希表 学生姓名 唐鹏 学生学号 ...1根据输入建立图书名称表采用创建散列表实现 2建散列表后如果想要查找的数据在散列表中输出yes否则输出no 哈希表简介 结构中存在关键字和K相
  • 数据结构课程设计 哈希表实验报告 福建工程学院 课程设计 课程 算法与数据结构 题目 哈希表 专业 网络工程 班级 xxxxxx班 座号 xxxxxxxxxxxx 姓名: xxxxxxx 12月 31日 实验题目哈希表 一 要解决的问题 针对同班同学...
  • 散列表的设计实验报告 1题目 散列表的设计:针对某个集体中人名设计一个散列表使得平均查找长度不超过R,并完成相应的建表和查表程序 2基本要求 假设人名为中国人姓名的汉语拼音形式待填入哈希表的人名共30个取平均...
  • 数据结构实验报告哈希表查找名字字符串 实验题目哈希表查找名字字符串 实验目标 输入一组名字至少50个将其保存并利用哈希表查找输出哈希查找冲突次数哈希表负载因子查找命中率 数据结构 哈希表和数组二维二维数组...
  • 数据结构试验报告(实验一)哈希表设计,实验报告,实验代码 用c++编写的
  • 题目:编程实现哈希表的造表和查找算法。 要求:用除留余数法构造哈希函数,用二次探测再散列解决冲突。 需求分析 用户可以根据自己的需求输入一个顺序表(哈希表) 通过用除留余数法构造哈希函数,并用开放地址的二...
  • 数据结构哈希表实验

    2014-03-02 12:54:06
    哈希表的代码,可以用于数据结构试验交作业或者用于写实验报告
  • 现在要求针对某个数据集合中的关键字设计一个哈希表(选择合适的哈希函数和处理冲突的方法),完成HAXI表的建立、查找,并计算HAXI表查找成功的平均查找长度。HAXI函数的构造方法有多种,其中除留余数法是一种最简单...
  • 数据结构与算法实验报告 实验 实验四 哈希表设计 学院   专业(班级)   姓名   学号   教师 ...

     

    数据结构与算法实验报告

    实验

    实验四 哈希表设计

    学院

     

    专业(班级)

     

    姓名

     

    学号

     

    教师

     

    实验四 哈希表设计

     

    1实验目的

    1.熟悉有关哈希表的基本概念;

    2.熟悉构造哈希表的方法;

    3.掌握哈希冲突的处理方法。

    2实验要求

    1.根据教材给出的方法,自己设计哈希表的存储结构;

    2.根据教材给出的方法,自己设计哈希函数和处理冲突的方法;

    3.实现哈希表的基本操作,完成哈希表的查找过程。

    3实验环境

    硬件平台:计算机CPU 主频2.0G以上;内存128兆以上;

    软件平台:Windows2003或以上版本,Visual C++6.0。

    4实验内容

    1.根据教材给出的方法,选择一种哈希函数的设计方法和处理冲突的方法,设计一种哈希表;输入一批关键字集合,建立哈希表。

    2.实现哈希表的基本操作:创建、销毁、取元素个数、置空、判空、赋值、取值、插入、删除等。

    3.完成哈希表的查找过程。

    5实验步骤

    • 需求分析:
    1. 本实验要求建立哈希表,并对哈希表进行增删查操作。
    2. 不经历任何比较,一次存取便能得到所查记录,因此在记录的存储位置和关键字之间建立一个确定的对应关系,使每个关键字和结构中一个唯一的存储位置相对应。对应的建立一个这样的哈希函数。
    3. 对不同的关键字可能得到同一散列地址,即key1!=key2,但是f(key1)=f(key2)。这就产生了冲突,因此需要处理冲突的函数。
    4. 根据哈希函数和处理冲突的方法将一组关键字映像到有限的连续地址上,便建立了哈希表。查找时也根据哈希函数和处理冲突方法,找到关键字地址,找到关键字。

     

    • 概要设计:

    哈希表的存储结构:

    typedef struct {

    ElemType *elem;

    int count;

    int sizeindex;

    }HashTable;//哈希表的结构

     

    int hashsize[]={997,...}//哈希表容量递增表,一个合适的素数序列

     

    Status Hash(int K){

    return K%m;

    }//哈希函数(除留余数法)

     

    void collision(int *p,int d)//处理冲突函数(我在本次实验中使用了两种方法,开放定址法和链地址法)

     

    Status SearchHash(HashTable H,KeyType K,int &p,int &c){}

    // 在开放定址哈希表H中查找关键码为K的元素,若查找成功,以p指示待查数据。

     

    Status InsertHash(HashTable &H,ElemType e){}

    //查找不成功时插入数据元素e到开放定址哈希表H中,并返回OK;若冲突次数过大,则重建哈希表。

     

    三.程序思想

    1.哈希函数:生成映射地址。

    2.处理冲突函数:对冲突的关键字进行处理。

    3.插入函数:插入关键字,先计算关键字的映射地址,然后在相应的地址插入,如果冲突,则利用处理冲突函数查找空位插入。

    4.查找函数:先计算关键字的地址,再判断是否冲突,再到散列表中查找。

     

    四.功能流程图

                                                       程序流程

                                               哈希表的插入

                                                 哈希表的查找

    五.程序运行截图:

                                                                     界面

                             

                                                          哈希表的查找

                                             哈希表的创建(链地址法)

                                         哈希表的查找(链地址法)

    六.程序源代码:

     

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include<iostream>
    #include<stack>
    #define TRUE 1
    #define FALSE 0
    #define OK 1
    #define ERROR 0
    #define INFEASIBLE -1
    #define OVERFLOW -2
    #define SUCCESS 1
    #define UNSUCCESS 0
    #define DUPLICATE -1
    #define NULLKEY 0
    using namespace std;
    typedef int KeyType;
    typedef int Status;
    int m=0;
    int N;
    int hashsize[]={11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997};
    typedef struct{
    	KeyType key;
    }ElemType;
    
    struct ElemType1{
    	KeyType key;
    	struct ElemType1*next;
    };
    
    typedef struct HashTable2{
    	ElemType1 **elem;//二级指针型向量,采用动态分配空间大小
    	int count;//当前的头指针向量的元素
    	int hashindex;//hashsize[H.hashindex]为当前容量
    }HashTable1;
    
    typedef struct {
    	ElemType *elem;
    	int count;
    	int sizeindex;
    }HashTable;
    
    int SearchHashTable1(ElemType1 *L, KeyType K, ElemType1 *&v){
    	ElemType1 *s = NULL;
    	s = (ElemType1*)malloc(sizeof(ElemType1));
    	s->key = K;
    	if (!L->next){//一开始为空,插入一个元素
    		s->next = L->next;
    		L->next = s;
    		v = s;
    		return 0;
    	}
    	else{
    		ElemType1* p = L->next;
    		ElemType1 *q = L;
    		while (p&&p->key != K){
    			q = p;
    			p = p->next;
    		}
    		if (p&&p->key == K){
    			v = p;
    			return 1;//找到了数据元素
    		}
     
    		else{//插入一个数据,此时p为空,需要她的前驱指针q指向最后一个元素,采用尾插法插入元素
    			s->next = q->next;
    			q->next = s;
    			v = s;
    			return 0;
    		}
    	}
     
    }
    
    Status Hash(int K){
    	return K%m;
    }//哈希函数 
    
    void InitHashTable1(HashTable1 &H){
    	H.count = 0;
    	m = hashsize[0];
    	H.elem = (ElemType1**)malloc(m*sizeof(ElemType1*));
    	for (int i = 0; i < m; i++){
    		H.elem[i] = (ElemType1*)malloc(sizeof(ElemType1));
    		H.elem[i]->next = NULL;
    	}
    }
    
    ElemType1* SearchHashTable1(HashTable1 H, KeyType K, int &p){
    	p = Hash(K);//p为根据关键字计算的处的头结点所在的位置,关键
    	ElemType1 *head = H.elem[p];//记下头结点,关键字记录肯定在以head为头结点的单链表中
    	return head;
    }
    
    void TraverseHashTable1(HashTable1 H){
    	ElemType1 *p = NULL, *q = NULL;
    	for (int i = 0; i < m; i++){
    		if ((p = H.elem[i])->next){//头结点不空
    			printf("\n进入了链表,地址为%d:\n",i);
    			q = p->next;//指向首节点
    			while (q){
    				printf("%d->", q->key);
    				q = q->next;
    			}
    		}
    	}
    	printf("\n");
    }
    
    ElemType1* InsertHashTable1(HashTable1&H, ElemType1 e){
    	int p = 0;//为插入的位置
    	ElemType1*v = NULL;
    	ElemType1*head = SearchHashTable1(H, e.key, p);//找到数据项e应该插入的头结点所在的链表
    	//SearchHashTableLinkListElemType;
    	SearchHashTable1(head, e.key, v);//动态查找链表
    	return v;//返回这个结点,不管找没找到,找到了返回,没找到会自动插入这个元素也返回
    	//在以head为头结点的链表中查找e.key关键字的元素
    }
    
    
    
    Status InitHash(HashTable &H){
    	H.count=0;
    	H.sizeindex=0;
    	m=hashsize[0];
    	H.elem=(ElemType *)malloc(m*sizeof(ElemType));
    	if(!(H.elem))
    	exit(0);
    	for(int i=0;i<m;i++){
    		H.elem[i].key=NULLKEY;
    	}
    	return 1;
    }//初始化哈希表 
    
    void DestroyHash(HashTable &H){
    	free(H.elem);
    	H.elem=NULL;
    	H.count=0;
    	H.sizeindex=0;
    }//销毁哈希表 
    
    void collision(int *p,int d){
    	*p=(*p+d)%m;
    }//处理冲突函数 
    
    
    
    Status SearchHash(HashTable H,KeyType K,int *p,int *c){
    	*p=Hash(K);
    	while(H.elem[*p].key!=NULLKEY&&!(K==H.elem[*p].key)){
    		(*c)++;
    		if(*c<m) 
    		collision(p,*c);
    		else break;
    	} 
    	if(K==H.elem[*p].key)
    	return SUCCESS;
    	else return UNSUCCESS;
    }//查找函数 
    
    Status InsertHash(HashTable *,ElemType);
    
    void RecreateHashTable(HashTable *H){
    	int i,count=(*H).count;
    	ElemType *p,*elem=(ElemType *)malloc(count*sizeof(ElemType));
    	p=elem;
    	printf("重建哈希表\n");
    	for(i=0;i<m;i++)
    	if(((*H).elem+i)->key!=NULLKEY)
    	*p++=*((*H).elem+i);
    	(*H).count=0;
    	(*H).sizeindex++;
    	m=hashsize[(*H).sizeindex];
    	p=(ElemType *)realloc((*H).elem,m*sizeof(ElemType));
    	if(!p)
    	exit(0);
    	(*H).elem=p;
    	for(i=0;i<m;i++)
    	(*H).elem[i].key=NULLKEY;
    	for(p=elem;p<elem+count;p++)
    	InsertHash(H,*p);
    }//重建哈希表 
    
    Status InsertHash(HashTable *H,ElemType e){
    	int c,p;
    	c=0;
    	if(SearchHash(*H,e.key,&p,&c))
    	return DUPLICATE;
    	else if(c<hashsize[(*H).sizeindex]/2){
    		(*H).elem[p]=e;
    		++(*H).count;
    		return 1;
    	}
    	else RecreateHashTable(H);
    	return 0;
    }//插入函数 
    
    
    void TraverseHash(HashTable H,void(*Vi)(int,ElemType)){
    	int i;
    	printf("哈希地址0~%d\n",m-1);
    	for(i=0;i<m;i++)
    	if(H.elem[i].key!=NULLKEY)
    	Vi(i,H.elem[i]);
    }//遍历函数 
    
    Status Find(HashTable H,KeyType K,int *p){
    	int c=0;
    	*p=Hash(K);
    	while(H.elem[*p].key!=NULLKEY&&!(K==H.elem[*p].key)){
    		c++;
    		if(c<m)
    		collision(p,c);
    		else return UNSUCCESS;
    	}
    	if(K==H.elem[*p].key){
    		printf("找了%d次\n",c+1);
    		return SUCCESS;
    	}
    	
    	else return UNSUCCESS; 
    }//查找函数 
    
    void print(int p,ElemType r){
    	printf("关键字-->%d-->地址-->%d\n",r.key,p);
    }//打印函数 
    
    void mainview_user( )            //界面函数
    {	HashTable h;
    	HashTable1 h1; 
    	int j,p,x;
    	int l=1000;
    	ElemType r[N];
    	ElemType1 r1[l];
    	KeyType k;
    	InitHash(h);
    	InitHashTable1(h1); 
    	int c; 
    	while(1)
    	{
    		system("CLS");  //清除屏幕函数
    		printf("     ------------------------------------\n");
    		printf("      |**********哈希表***************|\n");
    		printf("      |********1   遍历哈希表*********|\n");
    		printf("      |********2   插入哈希表*********|\n");
    		printf("      |********3   构建哈希表*********|\n");
    		printf("      |********4   销毁哈希表*********|\n");
    		printf("      |********5   哈希表的查找*******|\n");
    		printf("      |********6   构造哈希表(链地址法)|\n");
    		printf("      |********7   哈希表的查找(链地址法|\n");
    		printf("      |********0   退出系统***********|\n");
    		printf("     ------------------------------------\n");
    		printf("\n");
    		
    		printf("请选择:");
    		scanf("%d",&c);
    		switch(c)
    		{
    		case 1: {
    			printf("按哈希表地址顺序遍历哈希表:\n");
    			TraverseHash(h,print);
    			break;
    		}
    		case 2: {
    			printf("请输入要插入的关键字:");
    			scanf("%d",&k); 
    			j=Find(h,k,&p);
    			while(1){
    				if(j==SUCCESS){
    					printf("表中有该元素请重新输入:");
    					scanf("%d",&k); 
    					
    					j=Find(h,k,&p);
    				}
    				else break;
    			} 
    			r[N].key=k;
    			j=InsertHash(&h,r[N]);
    			if(j==0)
    			j=InsertHash(&h,r[N]);
    			printf("插入成功\n");
    			TraverseHash(h,print);
    			N+=1;
    			break; 
    		}
    		case 3: {
    			printf("请输入要输入的关键字数目:");
    			scanf("%d",&N);
    			int j;
    			printf("请输入关键字:"); 
    			for(int i=0;i<N;i++){
    				scanf("%d",&r[i].key);
    				j=InsertHash(&h,r[i]);
    				if(j==DUPLICATE)
    				printf("表中已有关键字为%d的记录,无法再插入记录(%d)\n",r[i].key,r[i].key);		
    				if(j==0)
    				j=j=InsertHash(&h,r[i]);
    			}
    			TraverseHash(h,print);
    			break;
    		}	
    		case 4:{
    			DestroyHash(h);
    			printf("销毁成功\n");
    			break;
    		} 
    		case 5:{
    			printf("请输入待查找的关键字:");
    			scanf("%d",&k);
    			j=Find(h,k,&p);
    			if(j==SUCCESS)
    			print(p,h.elem[p]);
    			else printf("没找到\n");
    			break;
    		}
    		case 6: {
    			printf("请输入要输入的关键字数目:");
    			scanf("%d",&l);
    			int j=0;
    			printf("请输入关键字:"); 
    			for(int i=0;i<l;i++){
    				scanf("%d",&r1[i].key);
    					InsertHashTable1(h1,r1[i]);
    				}
    			TraverseHashTable1(h1);
    			break;
    		}
    		case 7:{
    			printf("请输入待查找的关键字:");
    			scanf("%d",&k);
    			int flag=0;
    			ElemType1 *q = NULL,*t=NULL;
    			q=SearchHashTable1(h1,k,p);
    			if (q->next){//头结点不空
    			printf("\n进入了链表,地址为%d:\n",Hash(k));
    			t = q->next;//指向首节点
    			while (t){
    				printf("%d->", t->key);
    				if(t->key==k){
    					printf(" 找到了\n");
    					break;
    				}
    				 
    				t= t->next;
    			}
    			printf("没找到\n");
    		}
    			else printf("没找到\n");
    			break;
    		}	
    		case 0: {
    			    DestroyHash(h);
    				return;
    				 }
    		default:printf("输入错误,请重新输入!\n");fflush(stdin);  
    		}
    		printf("\n\n");
    		
    		system("PAUSE");
    	}
    }
    
    int main(){
    	mainview_user();
    }
    展开全文
  • 数据结构》(C语言版本)的实验之一,哈希表设计。网上找的资源,共享。
  • 数据结构实验哈希表 Description 在n个数中,找出出现次数最多那个数字,并且输出出现的次数。如果有多个结果,输出数字最小的那一个。 Input 单组数据,第一行数字n(1<=n<=100000)。 接下来有n个数字,每...

    数据结构实验:哈希表

    Description
    在n个数中,找出出现次数最多那个数字,并且输出出现的次数。如果有多个结果,输出数字最小的那一个。
    Input
    单组数据,第一行数字n(1<=n<=100000)。
    接下来有n个数字,每个数字不超过100000000
    Output
    出现次数最多的数字和次数。
    Sample
    Input
    3
    1 1 2
    Output
    1 2
    Hint
    此题可采用除留余数法

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    int main()
    {
    	int space[100010], time[100010];//space存数字,time记录数字出现的次数
    	memset(space, 0, sizeof(space));
    	memset(time, 0, sizeof(time));
    	int n, i, j, x, t;
    	int minnum, maxtime;
    	minnum = maxtime = 0;
    	scanf("%d", &n);
    	for (i = 0; i < n; i++)
    	{
    		scanf("%d", &x);
    		for (j = 0;; j++)
    		{
    			t = (x + j) % n;//除留余数法
    			if (space[t] == 0)//该表位为空时
    			{
    				space[t] = x;
    				time[t]++;
    				if (time[t] > maxtime)//选取出现次数最多的
    				{
    					maxtime = time[t];
    					minnum = space[t];
    				}
    				else if (time[t] == maxtime && space[t] < minnum)//出现次数相同时,选择数字值最小的
    					minnum = space[t];
    				break;
    			}
    			else if (space[t] == x)//该表位不为空时
    			{
    				time[t]++;
    				if (time[t] > maxtime)//选取出现次数最多的
    				{
    					maxtime = time[t];
    					minnum = space[t];
    				}
    				else if (time[t] == maxtime && space[t] < minnum)//出现次数相同时,选择数字值最小的
    					minnum = space[t];
    				break;
    			}
    		}
    	}
    	printf("%d %d", minnum, maxtime);
    }
    
    展开全文
  • 通过本实验的学习,理解哈希表的构造原理及构造方法,进一步理解通过哈希表的使用提高查找效率的原理,为不同数据结构选择合适的查找算法奠定基础。 二、实验内容 【问题描述】 针对你所在的班级中的“人名”设计一...

    数据结构

    实验十二:(查找实验,设计性)

    一、实验目的

    通过本实验的学习,理解哈希表的构造原理及构造方法,进一步理解通过哈希表的使用提高查找效率的原理,为不同数据结构选择合适的查找算法奠定基础。

    二、实验内容

    【问题描述】
    针对你所在的班级中的“人名”设计一个哈希表,完成相应的建表和查表程序。
    【基本要求】
    假设人名为中国人姓名的汉语拼音形式。哈希函数用除留余数法构造。
    【测试数据】
    所在班级同学的姓名。
    【实现提示】
    字符的取码方法可直接利用C语言中的toascii函数,并可对过长的人名先作折叠处理。

    三、实验原理、方法和手段

    1、根据实验内容编程,上机调试、得出正确的运行程序。
    2、编译运行程序,观察运行情况和输出结果。

    四、实验环境、条件

    硬件:计算机一台。
    软件:DEV C++, Visual C++。

    五、实验组织运行要求

    以学生自主训练为主的开放模式组织教学。

    六、实验步骤

    根据问题描述按照基本要求设计并编写程序,对程序进行调试,并使用测试数据对程序进行测试,将运行结果进行截图、对所得到的的结果分析。

    七、实验报告

    记录数据结构设计的过程及实验步骤、上机过程中遇到的困难及解决办法、遗留的问题、意见和建议等。格式见学生实验报告。

    代码

    展开全文
  • 本人亲自做的课程设计,包括实验报告,源程序
  • 数据结构实验之查找七:线性之哈希表 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 根据给定的一系列整数关键字和素数p,用除留余数法定义hash函数H(Key)=Key%p,...

    数据结构实验之查找七:线性之哈希表

    Time Limit: 1000MS Memory Limit: 65536KB

    Problem Description

    根据给定的一系列整数关键字和素数p,用除留余数法定义hash函数H(Key)=Key%p,将关键字映射到长度为p的哈希表中,用线性探测法解决冲突。重复关键字放在hash表中的同一位置。

    Input

    连续输入多组数据,每组输入数据第一行为两个正整数N(N <= 1500)和p(p >= N的最小素数),N是关键字总数,p是hash表长度,第2行给出N个正整数关键字,数字间以空格间隔。

    Output

    输出每个关键字在hash表中的位置,以空格间隔。注意最后一个数字后面不要有空格。

    Example Input

    5 5
    21 21 21 21 21
    4 5
    24 15 61 88
    4 5
    24 39 61 15
    5 5
    24 39 61 15 39

    Example Output

    1 1 1 1 1
    4 0 1 3
    4 0 1 2
    4 0 1 2 0
    这个题目考察了哈希表另一种处理冲突的方式,线性探测,也就是如果当前的下标x=Hash(key)已经有元素已经放进去了,就去x+1, x+2……依次
    查询,直到找到一个没有放进去的下标,由于此题输入的数据中存在相同的元素,所以在查询hash(key)的下标下已经放进元素时,要判断一下是否
    是相同的元素,相同的元素放在相同的位置即可。
    #include <iostream>
    #include <string.h>
    using namespace std;
    int main(){
        int Hash[1500];
        int n, k, i;
        while(cin>>n>>k){
            memset(Hash, -1, sizeof(Hash));
            for(i = 0; i < n; i++){
                int x, t;
                cin>>x;
                t = x%k;
                if(Hash[t] == -1){
                    cout<<t;
                    Hash[t] = x;
                }
                else {
                    bool flag = false;
                    for(int j = 0; j < k; j++){   //判断是否有相同元素时要遍历一遍,不能直接比较x与Hash[t], 因为之前的x可能经过过冲突的
                        if(Hash[j] == x){         //的处理,这样的话x的下标就不是x%k那么简单了
                            cout<<j;
                            flag = true;
                            break;
                        }
                    }
                    if(!flag){
                        while(Hash[t%k] != -1)
                            t++;
                        cout<<t%k;
                        Hash[t%k] = x;
                    }
                }
                if(i == n-1)
                    cout<<endl;
                else
                    cout<<" ";
            }
        }
        return 0;
    }
    


    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,827
精华内容 1,130
关键字:

哈希表数据结构实验报告

数据结构 订阅