数据结构实验 散列表实验报告

合集下载

散列查找顺序表的实现实验报告

散列查找顺序表的实现实验报告

题目:顺序表的实现一、实验题目顺序表的实现二、实验目的⑴掌握线性表的顺序存储结构;⑵验证顺序表及其基本操作的实现;⑶理解算法与程序的关系,能够将顺序表算法转换为对应的程序。

三、实验内容与实现⑴建立含有若干个元素的顺序表;⑵对已建立的顺序表实现插入、删除、查找等基本操作。

实验实现#include<stdio.h>#include<memory.h>int a[10000];int arrlong(){int j;for(j=0;j<12;j++)if(a[j]==0)break;return j;}int Insect(int n,int s) ////插入{int j;for(j=0;j<10000;j++)if(a[j]==0)break;printf("要操作的元素\n");for(int i=0;i<j;i++)printf("%d ",a[i]);printf("\n");for(int i=j;i>n-1;i--)a[i+1]=a[i];a[n]=s;for(int k=0;k<j+1;k++)printf("%d ",a[k]);printf("\n");}int Search(int p) //查找{int j,h;for(j=0;j<12;j++){if(a[j]==0)break;}for(h=0;h<j;h++){if(a[h]==p){printf("查找到的数在第%d位\n",h+1);break;}}if(h==j)printf("查无此数\n");}int Delate(int g,int q) //删除{int j;g=g-1;for(int j=g;j<12;j++)a[j]=a[j+1];for(q =0;q<12;q++){if(a[q]==0)break;}for(int i=0;i<q;i++)printf("%d ",a[i]);printf("\n");}int main(){int y,c;printf(" 菜单\n");printf("-------------------------------------------------\n");printf("0 建表\n1 插入\n2 查找\n3 删除\n4 退出\n");printf("-------------------------------------------------\n");while(scanf("%d",&y)!=EOF){int n,x,s;if(y==0){memset(a,0,sizeof(a));printf("请输入元素的个数:\n");scanf("%d",&c);printf("请输入数据:\n");for(int i = 0;i < c;i++)scanf("%d",&a[i]);}else if(y==1){int L;printf("请输入插入的第几位\n");scanf("%d",&n);//输入L=arrlong();if(n<=L){printf("请输入插入的数字\n");scanf("%d",&s);Insect(n,s);}else{printf("输入有误\n");continue;}}else if(y==2){int p;printf("请输入要查找的数字\n");scanf("%d",&p);Search(p);}else if(y==3){int g,q,L;printf("请输入要删除数的位置\n");scanf("%d",&g);L=arrlong();if(L>=g){Delate(g,q);}else{printf("输入有误\n");printf(" 菜单\n");printf("-------------------------------------------------\n");printf("0 建表\n1 插入\n2 查找\n3 删除\n4 退出\n");printf("-------------------------------------------------\n");continue;}}else if(y==4)break;else{printf("输入有误\n");printf(" 菜单\n");printf("-------------------------------------------------\n");printf("0 建表\n1 插入\n2 查找\n3 删除\n4 退出\n");printf("-------------------------------------------------\n");continue;}printf(" 菜单\n");printf("-------------------------------------------------\n");printf("0 建表\n1 插入\n2 查找\n3 删除\n4 退出\n");printf("-------------------------------------------------\n");}}建立顺序表:插入操作:查找操作:删除操作:插入数据超出顺序表范围:查找不到输入数据:删除数据超出顺序表范围:四、实验心得1.掌握了为数组赋值的方法,深刻理解了数组的含义2.掌握了为数组排序的方法。

山东大学-数据结构实验报告-矩阵和散列表

山东大学-数据结构实验报告-矩阵和散列表

山东大学计算机科学与技术学院数据结构课程实验报告了Input函数和Output函数。

对问题三,仿课本所述,定义Term类作为SparseMatrix类的友元类,包含行、列、值三个要素的成员变量,用Term类的数组实现稀疏矩阵的行主映射存储。

查找行为的实现方式是,找到位于目标元素前一行的最后一个元素,再从这个元素开始向下搜索,直到找到和目标元素同一行但是列数小于目标元素的元素a[k-1],然后决定下一步的行为————插入一个新项Term作为a[k]并将已有元素向后移位,还是修改已存在的项a[k]。

以此原理编写了Store和Retrieve函数,并扩展编写了Input函数和Output函数。

对问题四,仿照课本例子编写了有序链表类SortedChain、开放寻址的散列表类HashTable、基于有序链表链接的散列表类ChainHashTable,并对这三个类分别扩展编写了Output函数。

3.测试结果(测试输入,测试输出)问题一:问题二:上图显示了输入不符合下三角方阵约束时,抛出异常并退出程序。

上图是正常运行的结果。

问题三:普通的输入和输出操作如下:矩阵相加:矩阵转置:问题四:以上图的数据为例。

从346就应该在链表链接的散列表上看到开放寻址解决冲突的例子。

返回开放寻址的输出段,可以看到符合预期的结果:4.实现源代码(程序风格清晰易理解,有充分的注释)/** TridiagonalMatrix.h** Created on: Nov 22, 2015* Author: xudp*/#ifndef TRIDIAGONALMATRIX_H_#define TRIDIAGONALMATRIX_H_#include<iostream>using namespace std;template<class T>class TridiagonalMatrix {public:// 1、创建三对角矩阵类,采用按列映射方式,提供 store 和 retrieve 方法。

散列表实验报告(不同装载因子下链表法和放寻址法对比)

散列表实验报告(不同装载因子下链表法和放寻址法对比)

散列表实验报告(不同装载因子下链表法和放寻址法对比)TOC \o “1-4“ \h \z \u 1 概述22 原理介绍22.1 散列表介绍22.2 直接寻址表32.3 散列函数32.3.1 除法散列42.3.2 乘法散列42.3.3 全域散列42.4 解决碰撞问题52.4.1 链接法52.4.2 开放寻址法52.4.2.1 线性探查62.4.2.2 二次探查62.4.2.3 双重散列73 算法说明73.1 概述73.2 使用链接法解决碰撞问题83.2.1 算法思想83.2.2 伪代码描述93.2.3 算法分析与证明103.3 使用开放寻址法的双重散列解决碰撞问题123.3.1 算法思想123.3.2 伪代码描述123.3.3 算法分析与证明143.4 两个算法的比较144 实验设计与分析165 C++实现与结果分析185.1 C++实现与结果185.2 结果分析266 实验总结和感想27概述该实验报告主要是通过介绍散列表的各种技术,包括散列函数、解决碰撞的机制等技术,并对两种解决碰撞的机制:链接法和开放寻址法进行分析和证明,并通过实验分析两者在不同的规模下的运行时间和空间占用的对比,来证明在“算法说明”一章中的理论分析。

原理介绍散列表介绍散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。

也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。

这个映射函数叫做散列函数,存放记录的数组叫做散列表。

它实际上是是普通数组概念的推广,因为可以对数组进行直接寻址,故可以而在O(1)时间内访问数组的任意元素。

如果存储空间允许,我们可以提供一个数组,为每个可能的关键字保留一个位置,就可以应用直接寻址技术。

基本概念若结构中存在关键字和K相等的记录,则必定在f(K)的存储位置上。

由此,不需比较便可直接取得所查记录。

称这个对应关系f为散列函数(Hash function),按这个思想建立的表为散列表。

数据结构与算法实验报告5-查找与排序

数据结构与算法实验报告5-查找与排序

北京物资学院信息学院实验报告
课程名_数据结构与算法
实验名称查找与排序
实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ ________ 学号___
一、实验目的
1.掌握线性表查找的方法;
2.了解树表查找思想;
3.掌握散列表查找的方法.
4.掌握插入排序、交换排序和选择排序的思想和方法;
二、实验内容
查找部分
1.实现顺序查找的两个算法(P307), 可以完成对顺序表的查找操作, 并根据查到和未查到两种情况输出结果;
2.实现对有序表的二分查找;
3.实现散列查找算法(链接法),应能够解决冲突;
排序部分
4.分别实现直接插入排序、直接选择排序、冒泡排序和快速排序算法
三、实验地点与环境
3.1 实验地点
3.2实验环境
(操作系统、C语言环境)
四、实验步骤
(描述实验步骤及中间的结果或现象。

在实验中做了什么事情, 怎么做的, 发生的现象和中间结果, 给出关键函数和主函数中的关键段落)
五、实验结果
六、总结
(说明实验过程中遇到的问题及解决办法;个人的收获;未解决的问题等)。

数据结构实验报告

数据结构实验报告

数据结构实验报告引言:本实验旨在通过对数据结构的学习和实践,加深对数据结构的理解和运用能力。

在本实验中,我们将探索各种数据结构的特点、优势和适用场景,并通过实验验证它们的效果和性能。

本报告将详细介绍实验的目的、实验设计和实验结果,以及对结果的分析和总结。

一、实验目的:本实验的主要目的是帮助学生理解和掌握以下内容:1. 数据结构的基本概念和分类;2. 各种数据结构的特点、优势和适用场景;3. 数据结构的实现方式和算法;4. 数据结构的性能分析和优化。

二、实验设计:1. 实验环境:本次实验使用的编程语言为C++,开发环境为Visual Studio。

2. 实验内容:本次实验包括以下几个部分:(1)线性表的实现和应用;(2)栈和队列的实现和应用;(3)树和图的实现和应用;(4)排序和查找算法的实现和应用。

3. 实验步骤:(1)根据实验要求,选择合适的数据结构进行实现;(2)编写相应的代码,并进行调试;(3)运行程序,测试数据结构的功能和性能;(4)根据实验结果进行分析和总结。

三、实验结果:1. 线性表的实现和应用:在本次实验中,我们实现了顺序表和链表两种线性表结构,并对它们进行了性能测试。

通过测试,我们发现顺序表适用于频繁进行查找操作的场景,而链表适用于频繁进行插入和删除操作的场景。

2. 栈和队列的实现和应用:我们实现了栈和队列两种数据结构,并进行了相应的性能测试。

通过测试,我们发现栈适用于需要实现后进先出(LIFO)的场景,而队列适用于需要实现先进先出(FIFO)的场景。

3. 树和图的实现和应用:我们实现了二叉树和图两种数据结构,并进行了相应的性能测试。

通过测试,我们发现二叉树适用于需要进行快速查找和排序的场景,而图适用于需要表示复杂关系和网络结构的场景。

4. 排序和查找算法的实现和应用:我们实现了常见的排序和查找算法,并进行了相应的性能测试。

通过测试,我们发现快速排序和二分查找算法在大规模数据处理中具有较高的效率和性能。

湖南大学数据结构试验8散列表问题

湖南大学数据结构试验8散列表问题

HUNAN UNIVERSITY 课程实习报告题目:散列表问题学生姓名刘乐学生学号20080820208专业班级通信工程2班指导老师朱宁波完成日期2010年6月8日一、需求分析:1.本程序来自于图书馆靠书名来检索想要查找的书问题。

2.本程序要求:(1)根据输入建立图书名称表,采用创建散列表实现。

(2)建散列表后,如果想要查找的数据在散列表中输出yes否则输出no。

3在dos系统下输入散列表内容和要查找的数据个数和数据。

4测试数据:二、概要设计为实现上述功能需要用到散列表的存储结构。

算法基本思想散列表存储的基本思想是用关键字的值决定数据元素的存储地址,散列表存储中解决碰撞的基本方法:①开放定址法:形成地址序列的公式是:Hi=(H(key)+di)% m,其中m是表长,di是增量。

根据di取法不同,又分为三种:a.di =1,2,…,m-1 称为线性探测再散列,其特点是逐个探测表空间,只要散列表中有空闲空间,就可解决碰撞,缺点是容易造成“聚集”,即不是同义词的关键字争夺同一散列地址。

b.di =12,-12,22,-22,… ,±k2(k≤m/2)称为二次探测再散列,它减少了聚集,但不容易探测到全部表空间,只有当表长为形如4j+3(j为整数)的素数时才有可能。

c.di =伪随机数序列,称为随机探测再散列。

②再散列法:Hi=RHi(key)i=1,2,…,k,是不同的散列函数,即在同义词产生碰撞时,用另一散列函数计算散列地址,直到解决碰撞。

该方法不易产生“聚集”,但增加了计算时间。

③链地址法:将关键字为同义词的记录存储在同一链表中,散列表地址区间用H[0..m-1]表示,分量初始值为空指针。

凡散列地址为i(0≤i≤m-1)的记录均插在以H[i]为头指针的链表中。

这种解决方法中数据元素个数不受表长限制,插入和删除操作方便,但增加了指针的空间开销。

这种散列表常称为开散列表,而①中的散列表称闭散列表,含义是元素个数受表长限制。

数据结构课程设计之散列表的设计与实现

数据结构课程设计之散列表的设计与实现

##大学数据结构课程设计报告题目:散列表的设计与实现院(系):计算机工程学院学生姓名:班级:学号:起迄日期: 2011.6.19-6.30指导教师:2010—2011年度第 2 学期一、需求分析1.问题描述:该题目要求设计散列表实现电话号码的查找,在建立散列表时分别要用姓名和电话号码作为关键字来建立,在建立时设计不同的散列函数以及利用不同的解决冲突的方法记录冲突的次数。

2.基本功能:本程序为实现对电话号码及其主要信息进行保存并查找,通过利用散列表实现查找功能。

实现了折叠法和除留余数法构造哈希函数,而在处理冲突时又分别用到了线性探测再散列和二次探测再散列。

3.输入输出:本程序需要输入的用户信息包含三个数据:姓名、电话号码、地址。

所用的数据类型是指针,而三个信息均为字符串(字符数组),并注意在输入姓名时需要输入拼音以便可以用折叠法构造哈希函数。

输出的用户信息是字符串。

二、概要设计1.设计思路:本程序用到了字符串,所以首先要定义各个字符串的长度;其次创建一个折叠函数,利用大写字母的八进制表示;分别用姓名和电话号码建立哈希表,由于电话号码是字符串,所以用atoi函数将字符串转换成整型。

2.数据结构设计:ADT HashTableSearch{数据对象D:D是具有相同特性的数据元素的集合。

数据关系R:数据元素同属一个集合。

基本操作P:CreatHash(HashTable h,Data a);初始条件:哈希函数存在操作结果:以a为关键字建立哈希表EQ(x,y);初始条件:哈希表已建立操作结果:验证两个关键字SearchHash(h,c);初始条件:哈希表已经建立操作结果:查找信息并输出冲突数}ADT HashTableSearch3.软件结构设计:Get函数void getmessage();打印函数void display();折叠函数int floding(char*);哈希函数int Hash(char*);冲突函数Status collision(int ,int);创建哈希表void CreatHash(HashTable*,Data*); 查找函数void SearchHash(HashTable*,int );三、详细设计#include<stdio.h>#include<string.h>#include<stdlib.h>#define SUCCESS 1#define UNSUCCESS 0#define DUPLICATE -1#define MAXSIZE 20 //数量#define MAX_SIZE 20//信息长度#define hashsize 51//hashtable长度最好为质数typedef int Status;typedef struct Data{char name[20];char tel[20];char add[20];};typedef struct{Data *elem[hashsize];int count;int sizeindex;}HashTable;int num;Data *a=0;HashTable h;Get函数void getmessage(){printf("需要输入用户的数量:");scanf("%d",&num);a=(Data*)malloc(num*sizeof(Data));for(int i=0;i<num;i++){printf("输入第%d用户的名字:",i+1);scanf("%s",a[i].name);printf("输入第%d用户的电话号码:",i+1);scanf("%s",a[i].tel);printf("输入第%d用户的地址:",i+1);scanf("%s",a[i].add);}}打印函数void display(){int i;for(i=0;i<num;i++)printf("名字%s 电话号码%s 地址%s\n",a[i].name,a[i].tel,a[i].add); }折叠函数int floding(char *s)// 用户名的折叠法{char str[20];char *a;int sum=0;strcpy(str,s);strupr(str);a=str;while(*a!=0){sum+=*a;*a++;}return sum;}哈希函数int Hash1(char *str)//折叠法哈希函数{int n;int m;n=floding(str);m=n%hashsize;return m;}int Hash2(char *str)//除留余数法哈希函数{int n;n=atoi(str);m=n%hashsize;return m;}解决冲突函数Status collision1(int &p,int &c)//线性探测再散列法解决冲突{int i,q;i=c/2+1;while(i<hashsize){if(c%2==0){c++;q=(p+i)%hashsize;if(q>=0)return q;elsei=c/2+1;}else{q=(p-i)%hashsize;c++;if(q>=0)return q;elsei=c/2+1;}}return UNSUCCESS;}Status collision2(int &p,int &c)//二次探测再散列法解决冲突{int i,q;i=c/2+1;while(i<hashsize){if(c%2==0){c++;q=(p+i*i)%hashsize;if(q>=0) return q;else i=c/2+1;else{q=(p-i*i)%hashsize;c++;if(q>=0) return q;else i=c/2+1;}}return UNSUCCESS;}构造哈希表函数void CreatHash1(HashTable *h,Data *a)//以姓名为关键字建立哈希表{int i,p,q,c;int n;printf("1.线性探测再散列\n");printf("2.二次探测再散列\n");printf("请选择解决冲突的方式:");scanf("%d",&n);for(i=0;i<num;i++){c=0;p=Hash1(a[i].name);q=p;while(h->elem[q]!=0){switch(n){case 1:q=collision1(p,c);break;case 2:q=collision2(p,c);break;}}h->elem[q]=&a[i];h->count++;printf("第%d个用户冲突的次数为%d次\n",i+1,c);}printf("以姓名方式建表成功\n");}void CreatHash2(HashTable *h,Data *a)//以电话号码为关键字建立哈希表{int i,p,q,c;int n;printf("1.线性探测再散列\n");printf("2.二次探测再散列\n");printf("请选择解决冲突的方式:");scanf("%d",&n);for(i=0;i<num;i++){c=0;p=Hash1(a[i].name);q=p;while(h->elem[q]!=0){switch(n){case 1:q=collision1(p,c);break;case 2:q=collision2(p,c);break;}}h->elem[q]=&a[i];h->count++;printf("第%d个用户冲突的次数为%d次\n",i+1,c);}printf("以电话号码方式建表成功\n");}Status EQ(char *x,char *y)//验证两个关键字是否一致{if(strcmp(x,y)==0)return 1;else return 0;}查找函数void SearchHash1(HashTable *h,int &c){ char str[20];int p,q;printf("请输入要查找的姓名:");scanf("%s",str);p=Hash1(str);q=p;while(h->elem[q]->name!=0&&!EQ(str,h->elem[q]->name))q=collision1(p,c);if(EQ(str,h->elem[q]->name)){printf("查找成功,用户信息为:\n");printf("姓名:%s 电话号码:%s 地址:%s \n",h->elem[q]->name,h->elem[q]->tel,h->elem[q]->add);}else printf("查找的用户不存在");}void SearchHash2(HashTable *h,int &c){ char str[20];int p,q;printf("请输入要查找的电话号码:");scanf("%s",str);p=Hash2(str);q=p;while(h->elem[q]->tel!=0&&!EQ(str,h->elem[q]->tel))q=collision2(p,c);if(EQ(str,h->elem[q]->tel)){printf("查找成功,用户信息为:\n");printf("姓名:%s 电话号码:%s 地址:%s \n",h->elem[q]->name,h->elem[q]->tel,h->elem[q]->add);}else printf("查找的用户不存在");}int main(){int m,c;while(1){printf(" ------------------------\n");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(" **********************************************\n");printf(" *特别声明:输入名字时请输入拼音,不要输入汉字*\n");printf(" **********************************************\n");printf("请输入命令:");scanf("%d",&m);switch(m){case 1:getmessage();break;case 2:display();break;case 3:CreatHash1(&h,a);break;case 4:CreatHash2(&h,a);break;case 5:SearchHash1(&h,c);break;case 6:SearchHash2(&h,c);break;case 7: printf("谢谢您的使用\n");return 0;break;default :printf("输入数字不合法,请重新输入\n");break;}}return 0;}调用函数图如下:四、调试分析编写程序时,先是没有考虑到程序运行时需要字符串和整型数据之间的转换,修改中用到了atoi函数。

数据结构实验 散列表实验报告

数据结构实验 散列表实验报告

数据结构实验散列表实验报告一、实验目的本次实验的主要目的是深入理解和掌握散列表这种数据结构的基本原理、实现方法以及其在实际应用中的性能特点。

通过实际编写代码和进行相关测试,提高对散列表的操作能力,并能够分析和解决在使用散列表过程中可能遇到的问题。

二、实验原理散列表(Hash Table)是一种根据关键码值(Key value)而直接进行访问的数据结构。

通过一个特定的函数(哈希函数)将关键码映射到表中的一个位置来访问记录,以加快查找的速度。

这个映射函数称为哈希函数,存放记录的数组称为哈希表。

哈希函数的设计至关重要,它需要尽可能地将不同的关键码值均匀地分布在哈希表中,以减少冲突的发生。

常见的哈希函数有直接定址法、除留余数法、数字分析法等。

冲突解决方法也是散列表中的重要部分。

当不同的关键码通过哈希函数映射到相同的位置时,就会产生冲突。

常见的冲突解决方法有开放定址法(线性探测、二次探测等)和链地址法。

三、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。

四、实验内容1、哈希函数的实现采用除留余数法实现哈希函数。

代码如下:```cppint hashFunction(int key, int tableSize) {return key % tableSize;}```2、散列表的创建与初始化使用动态数组创建散列表,并将所有位置初始化为空。

```cppclass HashTable {private:int table;int size;public:HashTable(int tableSize) {size = tableSize;table = new intsize;for (int i = 0; i < size; i++){tablei =-1; //-1 表示为空}}~HashTable(){delete table;}};```3、数据插入操作采用线性探测法解决冲突。

散列法的实验研究 课程设计报告

散列法的实验研究  课程设计报告

课程设计报告问题描述:(1) 散列法中,散列函数构造方法多种多样,同时对于同一散列函数解决冲突的方法也可以不同。

两者是影响查询算法性能的关键因素。

(2) 程序实现几种典型的散列函数构造方法,并观察,不同的解决冲突方法对查询性能的影响。

a.需求分析:散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。

对不同的关键字可能得到同一散列地址,即key1≠key2,而f(key1)=f(key2),这种现象称冲突。

具有相同函数值的关键字对该散列函数来说称做同义词。

综上所述,根据散列函数H(key)和处理冲突的方法将一组关键字映象到一个有限的连续的地址集(区间)上,并以关键字在地址集中的“象”作为记录在表中的存储位置,这种表便称为散列表,这一映象过程称为散列造表或散列,所得的存储位置称散列地址。

散列表的查找过程基本上和造表过程相同。

一些关键码可通过散列函数转换的地址直接找到,另一些关键码在散列函数得到的地址上产生了冲突,需要按处理冲突的方法进行查找。

对散列表查找效率的量度,依然用平均查找长度来衡量。

查找过程中,关键码的比较次数,取决于产生冲突的多少,产生的冲突少,查找效率就高,产生的冲突多,查找效率就低。

因此,影响产生冲突多少的因素,也就是影响查找效率的因素。

该课程设计要求比较几种哈希函数的构造方法和解决冲突的方法对查询性能的影响。

b.概要设计该程序实现对哈希函数的构造方法、处理冲突的方法及在哈希表中查找数据的功能。

用线性再散列方法建立哈希表,用代码实现为:typedef structint key;int si;}HashTable1;void CreateHashTable1(HashTable1 *H,int *a,int num)//哈希表线性探测在散列;{int i,d,cnt;for(i=0;i<HashSize;i++){H[i].key=0;H[i].si=0;}for(i=0;i<num;i++){cnt=1;d=a[i]%HashSize;if(H[d].key==0){H[d].key=a[i];H[d].si=cnt;}else{do{d=(d+1)%HashSize;cnt++;}while(H[d].key!=0);H[d].key=a[i];H[d].si=cnt;}printf("\n线性再探索哈希表已建成!");}用二次探测再散列建立哈希表,代码实现如下:void CreateHash3(HashTable3 *h,int *a,int num)//二次探索表{int i,p=-1,c,pp;for(i=0;i<num;i++){c=0;p=a[i]%HashSize;pp=p;while(h->elem[pp]!=NULL){pp=Collision(p,c);if(pp<0){printf("第%d个记录无法解决冲突\n",i+1);continue;}}h->elem[pp]=&(a[a[i]]);h->count++;printf("第%d个记录冲突次数为%d\n",i+1,c);}printf("\n建表完成!\n此哈希表容量为%d,当前表内存储的记录个数%d.\n",HashSize,h->count);}二次探测再散列法解决冲突int Collision(int p,int &c){int i,q;i=c/2+1;while(i<HashSize){if(c%2==0){c++;q=(p+i*i)%HashSize;if(q>=0)return q;elsei=c/2+1;}else{q=(p-i*i)%HashSize;c++;if(q>=0)return q;else i=c/2+1;}}return (-1);}用线性再散列法查找,代码实现如下:void SearchHash1(HashTable1 *h,int data) {int d;d=data%HashSize;if(h[d].key==data)printf("数字%d的探查次数为:%d\n",h[d].key,h[d].si);else{dod=(d+1)%HashSize;while(h[d].key!=data && d<HashSize);if(d<HashSize)printf("数字%d的探查次数为:%d\n",h[d].key,h[d].si);elseprintf("没有查找到你所输入的数\n");}用二次探测再散列法查找void SearchHash2(HashTable2 * h[],int data,int num){int d;Node *q;d=data%num;q=h[d]->link;while(q->key!=data && q->next!=NULL)q=q->next;if(q->next!=NULL)printf("数字%d的查找次数为:%d\n",q->key,q->next);elseprintf("没有找到你要查找的那个数\n");}用链地址法查找,代码实现如下:void CreateHashTable2(HashTable2 *ht[],int *a,int num)//哈希表链地址;{int i,d,cnt;Node *s,*q;for(i=0;i<num; i++){ht[i]=(HashTable2 *)malloc(sizeof(HashTable2)); ht[i]->link=NULL;}for(i=0;i<num;i++){cnt=1;s=(Node *)malloc(sizeof(Node));s->key=a[i];s->next=NULL;d=a[i]%num;if(ht[d]->link==NULL){ht[d]->link=s;s->si=cnt;}else{q=ht[d]->link;while(q->next!=NULL){q=q->next;cnt++;}cnt++;s->si=cnt;q->next=s;}}}c.详细设计(1)程序中结构体的定义typedef struct{int key;int si;}HashTable1;typedef struct node{int key;int si;struct node *next;}Node;typedef struct{Node *link;}HashTable2;typedef struct{int * elem[HashSize];int count;int size;}HashTable3;(2) 主函数模块void main(){int data;HashTable1 hash1[HashSize];HashTable2 * hash2[HashSize];HashTable3 * ha;ha=(HashTable3 *)malloc(sizeof(HashTable3));for(int i=0;i<HashSize;i++)ha->elem[i]=NULL;ha->count=0;ha->size=HashSize;int a[MaxSize];while(1){printf("\n ┏━━━━━━━━━━━━━━━┓");printf("\n ┃欢迎使用本系统┃");printf("\n ┏〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓┓"); printf("\n ┃★★★★★★散列法的实验研究★★★★★★┃"); printf("\n ┃【1】. 添加数据信息【2】数据的输出┃"); printf("\n ┃【3】. 建立哈希表(线性再散列) ┃"); printf("\n ┃【4】. 建立哈希表(二次探测再散列) ┃"); printf("\n ┃【5】. 建立哈希表(链地址法) ┃"); printf("\n ┃【6】. 线性再散列法查找┃"); printf("\n ┃【7】. 二次探测再散列法查找┃"); printf("\n ┃【8】. 链地址法查找┃"); printf("\n ┃【0】. 退出程序┃"); printf("\n ┗〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓┛"); printf("\n");printf("\n");printf("请输入一个任务选项>>>");int x;scanf("%d",&x);switch(x){case 1:GetIn (a);break;case 2:GetOut(a);break;case 3:CreateHashTable1(hash1,a,num);break;case 4:CreateHash3(ha,a,num);break;case 5:CreateHashTable2(hash2,a,num);break;case 6:printf("请输入你查找的数据:");scanf("%d",&data);SearchHash1(hash1,data);break;case 7:printf("请输入你查找的数据:");scanf("%d",&data);SearchHash3(ha,data);break;case 8:printf("请输入你查找的数据:");scanf("%d",&data);SearchHash2(hash2,data,num);break;case 0:exit(-1);}}}d.调试分析(1)程序的关键是掌握文件的相关操作、哈希函数的创建和运用、处理冲突的方法等。

散列表的设计与实现-数据结构课程设计报告

散列表的设计与实现-数据结构课程设计报告
{
printf("请输入姓名:\n");
scanf("%s",name);
printf("输出查找的信息:\n");
find2(name);
}
else
printf("输入错误~\n");
}
}
if(select==2)
{
printf("姓名散列结果:\n");
list2();
}
if(select==3)
while(p)
{
printf("%s %s %s\n",p->name,p->address,p->num);
p=p->next;
}
}
}
void list2() {
int i;
node *p;
for(i=0;i<20;i++)
{
p=nam[i]->next;
while(p)
{
printf("%s %s %s\n",p->name,p->address,p->num);
输入1实现查找记录功能,输入2实现姓名散列,输入3实现号码散列,输入4
实现清空记录,输入5实现保存记录,输入6实现退出系统。 Haxi()存储电话号码。
Haxi2()存储姓名。
input()输入节点。
addnode()添加节点。
create()新建节点。
create2()新建节点。
list()显示列表。
newname->next=nam[key2]->next;
nam[key2]->next=newname;

散列表实验报告

散列表实验报告

课程名称:数据结构实验项目:散列表题目:散列表实验一、需求分析1、实验目标掌握散列表的构造方法以及冲突处理方法,实现散列表的运算算法。

2、程序的输入和输出输入:void insertRec(char x[], char y[])输出:void print() {const char space[] = " ";int i, k;for (i = 0; i < N; i++) {k = H(a[i].key);cout << i << ":\t"<< a[i].key << "\t"<< a[i].value << "\t";if (strlen(a[i].key) > 0)cout << "(" << k << ")";cout << endl;}二、概要设计1、数据结构带头节点的线性链表。

主要的操作:查找节点,插入节点,更新节点,打印链表。

2、程序的模块分为两个程序文件。

主要模块如下:void init();void insertRec(char x[], char y[]);int searchRec(char x[]);int deleteRec(char x[]);void print();三、详细设计1、数据结构#include <cstdlib>#include <iostream>using namespace std;const int N = 17; //散列表长struct record { //记录char key[24];char value[24];int deleted;};record a[N]; //散列表int H(char key[]); //散列函数void init();void insertRec(char x[], char y[]);int searchRec(char x[]);int deleteRec(char x[]);void print();int main(int argc, char *argv[]){int i, k;char x[24], y[24];init();cout << "输入要插入的记录: \n";for (i = 0; i < 14; i++) {cin >> x >> y;insertRec(x, y);print();}system("PAUSE");return EXIT_SUCCESS;}void insertRec(char x[], char y[]) { int i, k;i = H(x);while (strlen(a[i].key) > 0) {i++; //线性探测if (i == N) i = 0; //绕回表头}strcpy(a[i].key, x);strcpy(a[i].value, y);}int deleteRec(char x[]) {}int searchRec(char x[]) {}int H(char key[]) {int i = key[0], j = key[1];return (i*i + j*j) % N;}void print() {const char space[] = " "; int i, k;for (i = 0; i < N; i++) {k = H(a[i].key);cout << i << ":\t"<< a[i].key << "\t"<< a[i].value << "\t";if (strlen(a[i].key) > 0)cout << "(" << k << ")"; cout << endl;}}void init() {int i;for (i = 0; i < N; i++) {strcpy(a[i].key, "");strcpy(a[i].value, "");a[i].deleted = 0;}}四、测试结果1、输入autumn 秋天2、输出0:1:2:3:4:5:6:7:8:9:10:11:12:autumn秋天<12>13:14:15:16:。

数据结构实验报告(哈希表)

数据结构实验报告(哈希表)

散列表的设计实验报告1、题目:散列表的设计:针对某个集体中人名设计一个散列表,使得平均查找长度不超过R,并完成相应的建表和查表程序。

2、基本要求:假设人名为中国人姓名的汉语拼音形式。

待填入哈希表的人名共30个,取平均查找长度上限为2,哈希函数用除留余数法构造,用伪随机探测再散列法处理冲突。

人名长度不超过20个字符。

可先对过长的人名作折叠处理。

3、设计思想:a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3)平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址H(key)=key MOD p,p<=m.b.哈希函数可以减少冲突,但不能避免。

通常用的处理冲突的方法有:(1)开放定址法,这种方法还包含三种形式,一种叫线性探测再散列,一种叫二次探测再散列,另一种叫伪随机探测再散列。

本实验采用的是第三种伪随机探测再散列。

求下一个开放地址的公式为:Hi=(H(k)+di)MOD m (Di=伪随机数序列)c.对哈希表的操作InitNameList() 操作结果:姓名(结构体数组)初始化CreateHashList() 操作结果:建立哈希表FindList() 操作结果:在哈希表中查找Display() 操作结果:显示哈希表4、程序结构图5、流程图6、数据测试7、程序清单#include<iostream>#include<string>using namespace std;#define HASH_LENGTH 50#define M 47#define NAME_NO 30typedef struct{ char *py;int k;}NAME;NAME NameList[HASH_LENGTH]; typedef struct{ char *py;int k;int si;//查找长度}HASH;HASH HashList[HASH_LENGTH]; void InitNameList(){ char *f;int r,s0,i;for (i=0; i<HASH_LENGTH; i++){NameList[i].py = new char[20];NameList[i].py[0] = 0;}strcpy(NameList[0].py, "lintingting"); strcpy(NameList[1].py, "chenxiaoping"); strcpy(NameList[2].py, "jianghaiyan"); strcpy(NameList[3].py, "wangtingting"); strcpy(NameList[4].py, "zhouhuihui"); strcpy(NameList[5].py, "zhuzhenguo"); strcpy(NameList[6].py, "wuqingwen"); strcpy(NameList[7].py, "chenzuopeng"); strcpy(NameList[8].py, "jinlining"); strcpy(NameList[9].py, "zhandakan"); strcpy(NameList[10].py, "linjiajia"); strcpy(NameList[11].py, "huangwenjun"); strcpy(NameList[12].py, "lizhongjing"); strcpy(NameList[13].py, "sushiding"); strcpy(NameList[14].py, "ouyangyaoyao"); strcpy(NameList[15].py, "chenwei");strcpy(NameList[16].py, "linxiaxiao"); strcpy(NameList[17].py, "zhanjie");strcpy(NameList[18].py, "baishujun"); strcpy(NameList[19].py, "gongqiaoqiao"); strcpy(NameList[20].py, "lvhaitao"); strcpy(NameList[21].py, "jiangqingsong"); strcpy(NameList[22].py, "gubaolong"); strcpy(NameList[23].py, "yehuaisong"); strcpy(NameList[24].py, "wangyuqin"); strcpy(NameList[25].py, "xuefeifei"); strcpy(NameList[26].py, "wujianshu"); strcpy(NameList[27].py, "zhanghuajiang"); strcpy(NameList[28].py, "zhengpan"); strcpy(NameList[29].py, "sudongdong");for(i=0;i<NAME_NO;i++){s0=0;f=NameList[i].py;for(r=0;*(f+r)!='\0';r++)s0=*(f+r)+s0;NameList[i].k=s0;}}void CreateHashList(){int i;for(i=0; i<HASH_LENGTH;i++){HashList[i].py=new char[20];HashList[i].py[0] = 0;HashList[i].k=0;HashList[i].si=0;}for(i=0;i<HASH_LENGTH;i++){int sum=0;int adr=(NameList[i].k)%M;int d=adr;if(HashList[adr].si==0) //如果不冲突{HashList[adr].k=NameList[i].k;HashList[adr].py=NameList[i].py;HashList[adr].si=1;}else //冲突{while (HashList[d].k!=0){d=(d+NameList[i].k%10+1)%M; //伪随机探测再散列法处理冲突sum=sum+1;};HashList[d].k=NameList[i].k;HashList[d].py=NameList[i].py;HashList[d].si=sum+1;}}}void FindList(){string name;int s0=0,r,sum=1,adr,d;cout<<"请输入人名的拼音:"<<endl;cin>>name;for(r=0;r<20;r++)s0+=name[r];adr=s0%M; //使用哈希函数d=adr;if(HashList[adr].k==s0)cout<<"姓名:"<<HashList[d].py<<endl<<"关键字:"<<s0<<endl<<"查找长度为: 1"<<endl;else if (HashList[adr].k==0)cout<<"无此记录!"<<endl;else{int g=0;while(g==0){d=(d+s0%10+1)%M;sum=sum+1;if(HashList[d].k==0){cout<<"无此记录!"<<endl;g=1;}if(HashList[d].k==s0){cout<<"姓名:"<<HashList[d].py<<endl<<"关键字:"<<s0<<endl<<"查找长度为:"<<sum<<endl;g=1;}};}}void Display(){int i;float average=0;cout<<"\n地址\t关键字\t\t搜索长度\tH(key)\t 姓名\n";for(i=0; i<50; i++){cout<<i<<" ";cout<<"\t"<<HashList[i].k<<" ";cout<<"\t\t"<<HashList[i].si<<" ";cout<<"\t\t"<<(HashList[i].k%M)<<" ";cout<<"\t "<<HashList[i].py<<" ";cout<<"\n";}for(i=0;i<HASH_LENGTH;i++)average+=HashList[i].si;average/=NAME_NO;cout<<"平均查找长度:ASL("<<NAME_NO<<")="<<average<<endl; }int main(){char x;InitNameList(); CreateHashList ();cout<<"d. 显示哈希表"<<endl<<"f. 查找"<<endl<<"任意键退出"<<endl<<"请选择:"<<endl;while(cin>>x){if(x=='d'){Display();cout<<endl;}else if(x=='f'){FindList();cout<<endl;}else break;}for (int i=0; i<HASH_LENGTH; i++){free(NameList[i].py);free(HashList[i].py);}return 0;}。

数据结构实习报告(共8篇)

数据结构实习报告(共8篇)

数据结构实习报告(共8篇)数据结构实习报告(共8篇)第1篇:数据结构实_报告附件:实_报告格式,如下:数据结构实_报告班级:姓名:xxx(1514)xxx(1514)xxx(1514)指导教师:日期:题目一、问题描述(把你所选的题目及要求说一下)二、概要设计(抽象数据类型定义)三、详细设计(主要算法和函数间的调用关系)四、调试分析(调式过程中出现的问题及如何改正)五、心得体会(组内成员的分工及实_期间的体会)六、用户手册(系统的使用方法介绍)可参照_题集上的实_报告格式。

第2篇:数据结构实_报告数据结构实_报告班级:13软件二班姓名:殷健学号:1345536225子集和数问题1:问题描述子集和数问题1:子集和问题的为W,c。

其中,W=w1,w2,.,wn是一个正整数的集合,子集和数问题判定是否存在W的一个子集W1,使得W1=cW(02:问题分析程序中设计了函数voidputeSumofSub(ints,intk,intr),其意义是从第k项开始,如果s(已经决策的和数)和wk(当前元素)之和为和数,就把结果输出来,否则如果s与,wk,wk+1之和小于和数,则调用puteSumofsub(s+wk,k+1,r-wk),意为选择此结点的左分支,再判断s和后面所有元素之和是否不小于M(所有的加起来都小,必定无解),并且s+wk+1M,也是无解),若条件符合即调用puteSumofSub(s,k+1,r-wk),即选择当前结点的右分支。

算法展示:#includeusingnamespacestd;#include#include#defineM50claSu mOfSubprivate:intwM;intm;intxM;public:SumOfSub(inta,intb, intn)for(inti=0;i=mvoidmain()intsum=0;intwM;srand(unsigne d)time(NULL);for(inti=0;icoutcoutcoutm;sum=m*sum;cout复杂性分析:对于不同的输入结果,算法的执行次数有所不同,最好情况是n,最坏情况是n*2n。

山东大学-数据结构实验报告-矩阵与散列表

山东大学-数据结构实验报告-矩阵与散列表

山东大学计算机科学与技术学院数据结构课程实验报告了Input函数和Output函数。

对问题三,仿课本所述,定义Term类作为SparseMatrix类的友元类,包含行、列、值三个要素的成员变量,用Term类的数组实现稀疏矩阵的行主映射存储。

查找行为的实现方式是,找到位于目标元素前一行的最后一个元素,再从这个元素开始向下搜索,直到找到和目标元素同一行但是列数小于目标元素的元素a[k-1],然后决定下一步的行为————插入一个新项Term作为a[k]并将已有元素向后移位,还是修改已存在的项a[k]。

以此原理编写了Store和Retrieve函数,并扩展编写了Input函数和Output函数。

对问题四,仿照课本例子编写了有序链表类SortedChain、开放寻址的散列表类HashTable、基于有序链表链接的散列表类ChainHashTable,并对这三个类分别扩展编写了Output函数。

3.测试结果(测试输入,测试输出)问题一:问题二:上图显示了输入不符合下三角方阵约束时,抛出异常并退出程序。

上图是正常运行的结果。

问题三:普通的输入和输出操作如下:矩阵相加:矩阵转置:问题四:以上图的数据为例。

从346就应该在链表链接的散列表上看到开放寻址解决冲突的例子。

返回开放寻址的输出段,可以看到符合预期的结果:4.实现源代码(程序风格清晰易理解,有充分的注释)/** TridiagonalMatrix.h** Created on: Nov 22, 2015* Author: xudp*/#ifndef TRIDIAGONALMATRIX_H_#define TRIDIAGONALMATRIX_H_#include<iostream>usingnamespace std。

template<class T>class TridiagonalMatrix {public:// 1、创建三对角矩阵类,采用按列映射方式,提供 store 和 retrieve 方法。

山东大学数据结构实验报告四

山东大学数据结构实验报告四

山东大学软件工程学院数据结构课程实验报告学号:姓名:班级:软件工程2014级2班实验题目:矩阵和散列表实验学时:实验日期: 2015.11.11实验目的:掌握特殊矩阵和稀疏矩阵。

掌握散列表及其应用。

硬件环境:实验室软件环境:Vistual Studio 2013实验步骤与内容:实验内容:1、创建三对角矩阵类,采用按列映射方式,提供store和retrieve 方法。

2、创建下三角矩阵类,采用按列映射方式,提供store和retrieve 方法。

3、创建稀疏矩阵类,采用行主顺序把稀疏矩阵映射到一维数组中,实现稀疏矩阵的转置和两个稀疏矩阵的加法操作。

4、使用散列表设计实现一个字典,假设关键字为整数且D为961,在字典中插入随机产生的500个不同的整数,实现字典的建立和搜索操作。

分别使用线性开型寻址和链表散列解决溢出。

代码体:ChainHashTableNode.h#pragma once#include"ChainHashTableNode.h"using namespace std;class ChainHashTable{public:ChainHashTable(int divisor);~ChainHashTable();bool Insert(int k);bool Search(int k);void print();private:int d;ChainHashTableNode *ht;};ChainHashTableNode.cpp#include"ChainHashTable.h"#include<iostream>using namespace std;ChainHashTable::ChainHashTable(int divisor) {d = divisor;ht = new ChainHashTableNode[d];}bool ChainHashTable::Insert(int k){int j = k%d;if (ht[j].Insert(k)){return true;}else{return false;}}void ChainHashTable::print(){for (int i = 0; i < d; i++){ht[i].print();}}ChainHashTableNode.h#pragma once#include"Node.h"class ChainHashTableNode{public:ChainHashTableNode();bool Insert(int k);bool Search(int k);void print();private:Node *first;};ChainHashTableNode.cpp#include"ChainHashTableNode.h"#include<iostream>using namespace std; ChainHashTableNode::ChainHashTableNode() {first = 0;}bool ChainHashTableNode::Search(int k) {if (first == 0) return false;Node *current = first;while (current){if (current->value == k){return true;}current = current->link;if (current){if (current->value == k){return true;}}}return false;}bool ChainHashTableNode::Insert(int k) {if (Search(k)){cout << "已经存在此元素" << endl;return false;}else {Node *p = new Node();p->value = k;if (first == 0){first = p;return true;}else{p->link = first;first = p;return true;}}}void ChainHashTableNode::print(){Node *current = first;if (first){while (first){cout << first->value << " ";first = first->link;}cout << endl;first = current;}else {cout << -1 << endl;}}HashTable.h#pragma onceclass HashTable{public:HashTable(int divisor);~HashTable();int Search(int k);//搜索算法bool Insert(int e);void print();private:int hSearch(int k);int d;//除数int *ht;//桶,大小取决于d就是除数是多少bool *empty;//一维数组,用来存储第I个桶是否存入了元素};HashTable.cpp#include"HashTable.h"#include<iostream>using namespace std;HashTable::HashTable(int divisor){d = divisor;ht = new int[d];empty = new bool[d];for (int i = 0; i < d; i++){empty[i] = true;ht[i] = 0;}}HashTable::~HashTable(){delete[]ht;delete[]empty;}int HashTable::hSearch(int k)//搜索值为K的元素{int i = k%d;int j = i;do{if (ht[j] == k || empty[j]) return j;j = (j + 1) % d;} while (j != i);return j;}int HashTable::Search(int k)//搜索值为K的元素{int b = hSearch(k);if (ht[b] == k) return b;return -1;}bool HashTable::Insert(int e){int b = hSearch(e);if (empty[b]){ht[b] = e;empty[b] = false;return true;}else if (ht[b] == e){cout << "已经存在此元素" << endl;return false;}else{cout << "表已经满了" << endl;return false;}}void HashTable::print(){for (int i = 0; i < 961; i++){cout << ht[i] << " ";}cout << endl;return;}LowerTriangularMatrix.h#pragma onceclass LowerTriangularMatrix{public:LowerTriangularMatrix(int size);void Store(int x, int i, int j);//向矩阵里存储一个元素int Retrieve(int i, int j);//返回矩阵中的一个元素void print();private:int n;//矩阵维数int sum;//矩阵非零元素个数int *t;//用数组来存储矩阵};LowerTriangularMatrix.cpp#include"LowerTriangularMatrix.h"#include<iostream>using namespace std;LowerTriangularMatrix::LowerTriangularMatrix(int size){n = size;sum = n*(n + 1) / 2;t = new int[sum];}void LowerTriangularMatrix::Store(int x, int i, int j){if (i<0 || j<0 || i >= n || j >= n){cout << "下三角矩阵行列输入错误" << i << " " << j << endl;return;}else if (x == 0){cout << "下三角所添加的元素必须非零" << endl;return;}else if (i<j){cout << "下三角添加元素位置错误" << endl;return;}t[sum - ((n - j)*(n - j + 1) / 2) + (i - j)] = x;return;}int LowerTriangularMatrix::Retrieve(int i, int j){if (i<0 || j<0 || i >= (n - 1) || j >= (n - 1)){cout << "三对角矩阵行列输入错误" << endl;return -1;}else if (i >= j){return t[sum - ((n - j)*(n - j + 1) / 2) + (i - j)];}else{return 0;}}void LowerTriangularMatrix::print(){for (int i = 0; i < sum; i++){cout << t[i] << " ";}cout << endl;return;}Node.h#pragma onceclass Node{friend class ChainHashTableNode;private:int value;Node *link;};Node.cpp#include"Node.h"using namespace std;SparseMatrix.h#pragma once#include"Term.h"class SparseMatrix{public:SparseMatrix(int row, int col);void transpose();void Store(int x, int i, int j);//向矩阵里存储一个元素void Add(SparseMatrix &b);//两个稀疏矩阵相加void print();private:int row, col;//数组维数int sum;//元素个数int maxsum;//最多的元素个数Term *t;//存储的数组};SparseMatrix.cpp#include"SparseMatrix.h"#include<iostream>using namespace std;SparseMatrix::SparseMatrix(int r, int c){row = r;col = c;sum = 0;maxsum = r*c;t = new Term[maxsum];}void SparseMatrix::transpose(){Term *cur = new Term[maxsum];int *ColSize = new int[col];int *RowNext = new int[row];for (int i = 0; i < col; i++) ColSize[i] = 0;for (int i = 0; i < row; i++) RowNext[i] = 0;for (int i = 0; i < sum; i++) ColSize[t[i].col]++;//表示每一列的非零元素个数RowNext[0] = 0;for (int i = 1; i < col; i++) RowNext[i] = RowNext[i - 1] + ColSize[i - 1];//表示新矩阵中每一行的矩阵的前面的矩阵的个数//进入转置操作for (int i = 0; i < sum; i++){int j = RowNext[t[i].col]++;cur[j].value = t[i].value;cur[j].col = t[i].row;cur[j].row = t[i].col;}delete t;t = cur;}void SparseMatrix::Store(int x, int i, int j){t[sum].value = x;t[sum].row = i;t[sum].col = j;sum++;return;}void SparseMatrix::print(){for (int i = 0; i < sum; i++){cout << t[i].value << " ";}cout << endl;return;}void SparseMatrix::Add(SparseMatrix &b)//两个稀疏矩阵相加{if (col != b.col || row != b.row){cout << "两个矩阵行列不同无法相加" << endl;return;}int sa = 0;int sb = 0;Term *cur = new Term[maxsum];int k = 0;while (sa < sum || sb < b.sum){if (t[sa].col == b.t[sb].col&&t[sa].row == b.t[sb].row){cur[k].col = t[sa].col;cur[k].row = t[sa].row;cur[k].value = t[sa].value + b.t[sb].value;k++;sa++;sb++;}else if (t[sa].row < b.t[sb].row){cur[k].value = t[sa].value;cur[k].row = t[sa].row;cur[k].col = t[sa].col;k++;sa++;}else if (t[sa].row > b.t[sb].row){cur[k].value = b.t[sb].value;cur[k].row = b.t[sb].row;cur[k].col = b.t[sb].col;k++;sb++;}else if (t[sa].col < t[sb].col){cur[k].col = t[sa].col;cur[k].row = t[sa].row;cur[k].value = t[sa].value;k++;sa++;}else{cur[k].value = b.t[sb].value;cur[k].row = b.t[sb].row;cur[k].col = b.t[sb].col;k++;sb++;}}sum = k;delete t;t = cur;return;}Term.h#pragma onceclass Term{friend class SparseMatrix;private:int col, row;int value;};Term.cpp#include"Term.h"TridiagonalMatrix.h#pragma onceclass TridiagonalMatrix{public:TridiagonalMatrix(int size);void Store(int x, int i, int j);//向矩阵里存储一个元素int Retrieve(int i, int j);//返回矩阵中的一个元素void print();private:int n;//矩阵非0元素个数int *t;//用数组来存储矩阵};TridiagonalMatrix.cpp#include"TridiagonalMatrix.h"#include<iostream>using namespace std;TridiagonalMatrix::TridiagonalMatrix(int size){n = size;t = new int[3 * n - 2];}void TridiagonalMatrix::Store(int x, int i, int j){if (i<0 || j<0 || i >= n || j >= n){cout << "三对角矩阵行列输入错误" << i << " " << j << endl;return;}else if (x == 0){cout << "三对角矩阵所添加的元素必须非零" << endl;return;}else if (abs(i - j)>1){cout << "三对角矩阵添加元素位置错误" << endl;return;}switch (i - j){case -1:t[3 * j - 1] = x;break;case 0:t[3 * j] = x;break;case 1:t[3 * j + 1] = x;break;}return;int TridiagonalMatrix::Retrieve(int i, int j){if (i<0 || j<0 || i >= (n - 1) || j >= (n - 1)) {cout << "三对角矩阵行列输入错误" << endl;return -1;}else if (abs(i - j) <= 1){return t[3 * j + (i - j)];}else{return 0;}}void TridiagonalMatrix::print(){for (int i = 0; i < 3 * n - 2; i++){cout << t[i] << " ";}cout << endl;return;}Test.cpp#include<iostream>#include<cstring>#include<cstdlib>#include"TridiagonalMatrix.h"#include"LowerTriangularMatrix.h"#include"SparseMatrix.h"#include"HashTable.h"#include"ChainHashTable.h"using namespace std;int wei, num[100][100];void c(){for (int i = 0; i < wei; i++)for (int j = 0; j < wei; j++)cin >> num[i][j];}int main(){int k = 0, l = 0;/*三对角矩阵实验开始测试数据4~10~3n-241 2 0 03 4 5 00 7 8 90 0 8 7*/cout << "请输入三对焦矩阵维数及内容:" << endl;cin >> wei;c();TridiagonalMatrix *TM = new TridiagonalMatrix(wei);for (int i = 0; i < wei; i++)for (int j = 0; j < wei; j++)if (num[j][i] != 0)TM->Store(num[j][i], j, i);TM->print();cout << "请输入要查询的元素的位置" << endl;cin >> k >> l;l = TM->Retrieve(k, l);cout << "查询结果:" << l << endl;cout << "***********************************************" << endl;/*下三角矩阵实验开始测试数据4~10~n*(n+1)/241 0 0 02 3 0 04 5 6 07 8 9 -1*/cout << "请输入下三角矩阵维数及内容:" << endl;k = 0, l = 0;cin >> wei;c();LowerTriangularMatrix *LTM = new LowerTriangularMatrix(wei);for (int i = 0; i < wei; i++)for (int j = 0; j < wei; j++)if (num[j][i] != 0)LTM->Store(num[j][i], j, i);cout << "请输入要查询的元素的位置" << endl;cin >> k >> l;l = LTM->Retrieve(k, l);cout << "查询结果:" << l << endl;cout << "***********************************************" << endl;/*稀疏角矩阵实验开始测试数据4 54 51 0 0 0 20 3 0 0 04 0 05 00 6 7 0 84 58 0 7 6 00 5 0 0 40 0 0 3 02 0 0 0 19 0 7 6 20 8 0 0 44 0 0 8 02 6 7 0 9*/cout << "请输入稀疏矩阵的维数及内容:" << endl;cin >> k >> l;SparseMatrix *SM = new SparseMatrix(k, l);for (int i = 0; i < k; i++)for (int j = 0; j < l; j++){cin >> num[i][j];if (num[i][j])SM->Store(num[i][j], i, j);}cout << "稀疏矩阵为: ";SM->print();SM->transpose();cout << "转置后稀疏矩阵为: ";SM->print();SM->transpose();cout << "重新转置后稀疏矩阵为: ";cout << "矩阵相加开始,请输入要使用的矩阵维数及内容:" << endl;cin >> k >> l;SparseMatrix *SM2 = new SparseMatrix(k, l);for (int i = 0; i < k; i++)for (int j = 0; j < l; j++){cin >> num[i][j];if (num[i][j])SM2->Store(num[i][j], i, j);}cout << "新矩阵为: ";SM2->print();SM->Add(*SM2);cout << "矩阵相加后为: ";SM->print();cout << "***********************************************" << endl;cin.get();system("pause");/*使用散列表设计实现一个字典,假设关键字为整数且D为961,在字典中插入随机产生的500个不同的整数,实现字典的建立和搜索操作。

散列表实验报告doc

散列表实验报告doc

散列表实验报告doc散列表实验报告篇一:数据结构实验散列表实验报告课程实验报告课程名称:实验项目名称:专业班级:姓名:学号:完成时间:月背景散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。

也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。

这个映射函数叫做散列函数,存放记录的数组叫做散列表。

在理想情况下,查找、插入、删除操作的时间均为O(1),是一种高效的动态集合结构。

例1:计算机程序设计语言的编译程序需要维护一个符号表,其中元素的关键值为任意字符串,与语言中的标识符对应。

该符号表常采用散列表。

例2:为了节约空间,常常需要把文本文件采用压缩编码方式存储。

LZW是对文本文件进行压缩和解压缩的方法之一,该方法采用了散列。

问题描述我们希望在浩瀚的图书中,去发现一本书是否存在。

我们不知道书的编号,只知道它的书名。

(其实这已经不错了...)。

通过书名,来查询它是否存在。

为了简化问题,我们假设每本书的书名都是一组小写字母组成,长度不超过100字符。

基本要求(1)根据输入建立图书名称表,采用散列表实现该表,散列函数选用BKDE 字符串哈希。

(2)数据的输入输出格式:输入分为两部分第一部分,第一行是行数n,n 第二部分,第一行是行数m,m 输出:输出为m行,如果被查的记录存在,则输出"YES",如果不存在则输出"NO"。

测试数据输入:4aansandhellocppaban。

数据结构实验散列表之欧阳家百创编

数据结构实验散列表之欧阳家百创编

计算机科学与技术系欧阳家百(2021.03.07)哈希表的设计与实现项目报告专业名称计算机科学与技术项目课程数据结构与算法项目名称哈希表的设计与实现班级项目人员钱海峰,郑秀娟,王传敏,杨青,凌波实验日期 2015.12.9目录一.设计目的 (3)二.问题分析 (3)三.设计环境 (3)四.人员分配 (3)五.详细设计和编码 (4)六.实验分析 (7)1测试分析 (7)2性能分析 (11)附录 (12)参考书目………………………………………………………………17一.设计目的(1)掌握散列结构和散列函数的相关概念(2)掌握散列结构的存储结构的相关概念(2)掌握散列冲突的处理方法(3)运用散列解决冲突问题。

二.问题分析要完成如下要求:设计哈希表实现整数查询系统。

实现本项目需要解决以下问题:(1)如何设计一个哈希表。

(2)如何在哈希表中插入记录。

(3)如何删除哈希表中的记录。

(4)如何查找并显示记录。

(5)如何解决冲突问题。

三.设计环境⒈硬件:计算机每人一台。

⒉软件:Windows操作系统和Microsoft Visual VC++6.0编译器。

四.人员分配五.详细设计和编码1.定义结点结构类型在链地址法中,每个结点对应一个链表结点,由3个域组成,结构如图9-1所示。

其中,key为关键字域,存放结点关键字;data 为数据域,存放结点数据信息;next为链域,存放指向下一个同义词结点的指针。

图9-1 链地址法结点结构链地址数据结构类型如下:#define MAX_LENGTH 50typedef struct node{int data;struct node *next;}ElemNode;typedef struct{ElemNode *first;}ElemHeader,HashTable[MAX_LENGTH];#include <stdio.h>2.对哈希函数的定义设计一个Hash()函数,本设计中对散列函数选择的是除留余数法,即对关键字进行模运算,将运算结果所得的余数作为关键字(或结点)的存储地址,即i=ht mod n,本设计n由用户自己输入,然后将计算出来的结果返回。

数据结构实验报告散列查找

数据结构实验报告散列查找

《数据结构》实验报告题目: 散列查找一、实验题目散列查找二、实验目的⑴掌握散列查找的基本思想;⑵掌握闭散列表的构造方法;⑶掌握线性探测处理冲突的方法;⑷验证散列技术的查找性能。

三、实验内容与实现⑴对于给定的一组整数和散列函数,采用线性探测法处理冲突构造散列表;⑵设计查找算法,验证查找性能。

实验实现:#include <stdio.h>#include <stdlib.h>#define HASHSIZE 10 // 长度#define NULLKEY -32768typedef struct{int *elem; // 数据元素存储地址,动态分配数组int count; // 当前数据元素个数}HashTable;int m = 0;int Init(HashTable *H){int i;m = HASHSIZE;H->elem = (int *)malloc(m * sizeof(int)); //分配内存H->count = m;for (i = 0; i<m; i++){H->elem[i] = NULLKEY;}return 1;}int Hash(int k)//除留余数法{return k % m;}void Insert(HashTable *H, int k)//插入数字如果有冲突用开放定址法{int addr = Hash(k);while (H->elem[addr] != NULLKEY){addr = (addr+1) % m;}H->elem[addr] = k;}int Search(HashTable *H, int k)//求哈希地址开放定址法解决冲突{int addr = Hash(k);while (H->elem[addr] != k){addr = (addr+1) % m;if (H->elem[addr] == NULLKEY || addr == Hash(k)) return -1;}return addr;}void Result(HashTable *H)//散列表元素显示{int i;for (i = 0; i<H->count; i++){if(H->elem[i]!=-32768)printf("%d ", H->elem[i]);}printf("\n");}int main(){int i, j, addr,n;HashTable H;int arr[HASHSIZE] = { NULL };Init(&H);printf("请输入数:");for (i = 0; i<10; i++)scanf("%d", &arr[i]);Insert(&H, arr[i]);}printf("输入的数存入哈希表后:");Result(&H);int b;printf("输入需要查找的数:\n");while(scanf("%d",&j)!=EOF){addr = Search(&H, j);if (addr == -1){printf("元素不存在,程序结束\n");break;}elseprintf("%d元素在表中的位置是:%d\n", j,addr+1); }}四、实验心得。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

课程实验报告
课程名称:数据结构
实验项目名称:散列表
专业班级:
姓名:XXX
学号:
完成时间:2015 年06 月13 日
背景
散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。

也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。

这个映射函数叫做散列函数,存放记录的数组叫做散列表。

在理想情况下,查找、插入、删除操作的时间均为O(1),是一种高效的动态集合结构。

例1:计算机程序设计语言的编译程序需要维护一个符号表,其中元素的关键值为任意字符串,与语言中的标识符对应。

该符号表常采用散列表。

例2:为了节约空间,常常需要把文本文件采用压缩编码方式存储。

LZW是对文本文件进行压缩和解压缩的方法之一,该方法采用了散列。

问题描述
我们希望在浩瀚的图书中,去发现一本书是否存在。

我们不知道书的编号,只知道它的书名。

(其实这已经不错了...)。

通过书名,来查询它是否存在。

为了简化问题,我们假设每本书的书名都是一组小写字母组成,长度不超过100字符。

基本要求
(1)根据输入建立图书名称表,采用散列表实现该表,散列函数选用BKDE 字符串哈希。

(2)数据的输入输出格式:
输入分为两部分
第一部分,第一行是行数n,n <= 5000。

余下n行,每行一个字符串。

表示已存
在的图书记录。

第二部分,第一行是行数m,m <= 1000。

余下m行,每行一个字符串。

表示要查
询的图书记录。

输出:
输出为m行,如果被查的记录存在,则输出"YES",如果不存在则输出"NO"。

测试数据
输入:
4
a
ans
and
hellocpp
9
a
b
an
as
ans
and
ande
hellocbb
hellocpp
输出:
YES
NO
NO
NO
YES
YES
NO
NO
YES
实现提示
(1)冲突处理方法为:顺次循环后移到下一个位置,寻找空位插入。

(2)BKDE 字符串哈希
unsigned int hash_BKDE(char *str)
{
/* 初始种子seed 可取31 131 1313 13131 131313 etc.. */
unsigned int seed = 131;
unsigned int hash = 0;
while (*str)
{
hash = hash * seed + (*str++);
}
return (hash & 0x7FFFFFFF);
}
将字符串哈希到小于2^31的整数t,再将t用随机数哈希法映射到2^15以内的数。

选做内容
每一种西文图书都有一个国际标准图书编号,它是一个10位的十进制数字,若要以它作关键字建立一个哈希表,当馆藏书种类不到10,000时,采用折叠法构造一个四位数的哈希函数。

课后题目
实现文本LZW压缩和解压缩。

源代码
#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;
unsigned int hash_BKDE(char *str)
{
unsigned int seed = 131;
unsigned int hash = 0;
while (*str)
{
hash = hash * seed + (*str++);
}
return (hash & 0x7FFFFFFF);
}
double k=(double)(rand()%999)/1000;
unsigned int hash_rand(unsigned int value)
{
double a=k*value;
double n=(a-(int)a)*64;
unsigned int seed=(int)n;
return seed;
}
unsigned int Hash(char*str)
{
return hash_rand(hash_BKDE(str)); }
class HashTable
{
public:
HashTable();
~HashTable();
void insert(char*c);
bool find(char*c);
private:
char**Arr;
int ArrSize;
};
HashTable::HashTable()
{
ArrSize=32768;
Arr=new char*[64];
for(int i=0;i<64;i++)
{
Arr[i]=new char[100];
Arr[i]=NULL;
}
}
HashTable::~HashTable()
{
for(int i=0;i<64;i++)
delete[]Arr[i];
delete []Arr;
}
void HashTable::insert(char*c)
{
unsigned int pos=Hash(c);
while(Arr[pos]!=NULL)
pos=(pos+1);
Arr[pos]=c;
}
bool HashTable::find(char*c)
{
unsigned int pos=Hash(c);
while(Arr[pos]!=NULL)
{
if(Arr[pos]==c)return true;
pos=(pos+1);
}
return false;
}
int main()
{
bool a[20];
char *c1=new char[100];
HashTable H;
cout<<"输入字符串个数n:\n";
int n;
cin>>n;
cout<<"输入n个字符串:\n";
for(int i=1;i<=n;i++)
{
cin>>c1;
H.insert(c1);
}
cout<<"输入待查的字符串个数m:\n";
int m;
cin>>m;
cout<<"输入要查找的字符串:"<<endl;
for(int j=0;j<m;j++)
{
cin>>c1;
a[j]=H.find(c1);
}
cout<<"查找结果(yes表示存在,no表示不存在):\n"; for(int k=0;k<m;k++)
if(a[k])
cout<<"YES\n";
else
cout<<"No\n";
system("pause");
return 0;
}
实验结果:
运行结果与要求相符,程序无误。

相关文档
最新文档