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

合集下载

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

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

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

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

实验实现#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.掌握了为数组排序的方法。

查找的实验报告

查找的实验报告

实验名称:查找算法性能分析实验目的:比较不同查找算法的效率,并分析其性能。

实验时间:2022年3月15日实验地点:计算机实验室实验器材:计算机、实验软件一、实验背景随着计算机技术的发展,数据量越来越大,查找算法在数据处理中的应用越来越广泛。

查找算法的效率直接影响到数据处理的速度,因此研究不同查找算法的性能具有重要意义。

本实验旨在比较几种常见的查找算法的效率,并分析其性能。

二、实验内容1. 算法介绍(1)顺序查找顺序查找是一种最简单的查找方法,其基本思想是从线性表的第一个元素开始,依次将线性表中的元素与要查找的元素进行比较,直到找到目标元素或者查找结束。

(2)二分查找二分查找是一种效率较高的查找方法,其基本思想是将待查找的序列分为两半,每次将中间位置的元素与要查找的元素进行比较,如果相等,则查找成功;如果中间位置的元素大于要查找的元素,则将查找范围缩小到左半部分;如果中间位置的元素小于要查找的元素,则将查找范围缩小到右半部分。

重复此过程,直到找到目标元素或者查找结束。

(3)散列查找散列查找是一种基于散列函数的查找方法,其基本思想是将要查找的元素通过散列函数映射到散列表中的一个位置,然后直接访问该位置,如果找到目标元素,则查找成功;如果未找到,则查找失败。

2. 实验步骤(1)生成随机数据使用实验软件生成一组随机数据,包括顺序查找和二分查找的数据。

(2)编写查找算法根据上述算法介绍,编写顺序查找、二分查找和散列查找的代码。

(3)测试算法性能分别对三种查找算法进行测试,记录查找成功和失败的情况,统计查找成功和失败的平均时间。

三、实验结果与分析1. 顺序查找(1)查找成功实验结果显示,顺序查找在查找成功的情况下,平均查找时间为0.1秒。

(2)查找失败实验结果显示,顺序查找在查找失败的情况下,平均查找时间为0.2秒。

2. 二分查找(1)查找成功实验结果显示,二分查找在查找成功的情况下,平均查找时间为0.05秒。

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

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

散列表实验报告(不同装载因子下链表法和放寻址法对比)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语言环境)
四、实验步骤
(描述实验步骤及中间的结果或现象。

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

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

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

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

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

实验实现:#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. 顺序表的定义顺序表是一种线性表的存储方法,它把线性表中的元素按其逻辑顺序依次存储在一段连续的存储区域中,也就是一维数组。

顺序表既可以用于存储静态数据,也可以用于存储动态数据。

2. 顺序表的实现顺序表的实现需要用到一维数组,当创建顺序表时,先要确定它的最大长度,然后根据长度创建相应大小的一维数组,接着插入数据时,依次将数据插入到数组中,需要注意的是,数组是从0开始储存的,而不是从1开始。

以下是顺序表的实现代码示例:```python# 设定最大长度为10MAX_SIZE = 10class SeqList:def __init__(self):self.seq = [None] * MAX_SIZEdef insert(self, index, value):# 检查是否超出最大长度,或者下标越界if index < 0 or index > MAX_SIZE or index >= len(self.seq): raise IndexError# 移动数组,腾出位置for i in range(MAX_SIZE - 1, index - 1, -1):self.seq[i] = self.seq[i - 1]# 插入数据self.seq[index] = valuedef pop(self, index):# 检查下标合法性if index < 0 or index >= len(self.seq):raise IndexError# 移动数组,删除数据for i in range(index, MAX_SIZE - 1):self.seq[i] = self.seq[i + 1]# 最后一位设为None,释放空间self.seq[-1] = Nonedef __repr__(self):return str(self.seq)```3. 顺序表的应用顺序表可以用于很多场景,比如存储学生成绩、成绩排名、图书管理等,以下是一个简单的例子:存储学生成绩并排序```pythonseq = SeqList()seq.insert(0, 89)seq.insert(1, 92)seq.insert(2, 76)seq.insert(3, 68)seq.insert(4, 100)print(seq)```输出:`[89, 92, 76, 68, 100, None, None, None, None, None]` 对学生成绩进行排序:```pythonseq.seq.sort(reverse=True)print(seq)```输出:`[100, 92, 89, 76, 68, None, None, None, None, None]` 结论通过本次实验,我们掌握了顺序表的定义、实现及其应用,顺序表在大多数情况下提供了比较高效的数据访问,因此在实际开发中非常有用。

数据结构查找实验报告

数据结构查找实验报告

一、实验目的1. 理解并掌握几种常见查找算法的基本原理和实现方法。

2. 比较不同查找算法的时间复杂度和空间复杂度。

3. 通过实验验证查找算法的效率和适用场景。

二、实验内容本次实验主要涉及以下查找算法:1. 顺序查找法2. 二分查找法3. 散列查找法三、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 开发环境:PyCharm四、实验步骤1. 实现顺序查找法2. 实现二分查找法3. 实现散列查找法4. 编写测试程序,分别对三种查找算法进行测试5. 比较三种查找算法的性能五、实验结果与分析1. 顺序查找法(1)实现代码```pythondef sequential_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn -1```(2)测试程序```pythonarr = [5, 3, 8, 6, 2, 7, 4, 9, 1]target = 6print("顺序查找结果:", sequential_search(arr, target))```(3)分析顺序查找法的时间复杂度为O(n),空间复杂度为O(1)。

当数据量较大时,查找效率较低。

2. 二分查找法(1)实现代码```pythondef binary_search(arr, target):left, right = 0, len(arr) - 1while left <= right:mid = (left + right) // 2if arr[mid] == target:return midelif arr[mid] < target:left = mid + 1else:right = mid - 1return -1```(2)测试程序```pythonarr = [1, 2, 3, 4, 5, 6, 7, 8, 9]target = 6print("二分查找结果:", binary_search(arr, target))```(3)分析二分查找法的时间复杂度为O(log2n),空间复杂度为O(1)。

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

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

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

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

二、实验原理散列表(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. 实验目的•理解顺序表的概念和特性。

•学习顺序表的基本操作,包括插入、删除、查找和修改等。

•掌握顺序表的实现方法,包括静态分配和动态分配两种方式。

•培养对数据结构的抽象思维和编程能力。

3. 实验内容1.了解顺序表的定义,及其与数组的关系。

2.掌握插入操作的实现方法,包括在表头、表中和表尾插入元素。

3.掌握删除操作的实现方法,包括按索引删除和按值删除。

4.掌握查找操作的实现方法,包括按索引查找和按值查找。

5.掌握修改操作的实现方法,包括按索引修改和按值修改。

6.实现顺序表的静态分配和动态分配两种方式。

4. 实验步骤1.定义顺序表的结构体,包括数据存储区和长度属性。

2.实现插入操作,根据需要选择插入位置和移动元素。

3.实现删除操作,根据需要选择删除方式和更新长度。

4.实现查找操作,根据需要选择查找方式和返回结果。

5.实现修改操作,根据需要选择修改方式和更新元素。

6.实现顺序表的静态分配和动态分配方法。

5. 实验结果经过多次实验和测试,顺序表的基本操作都能够正确实现。

在插入操作中,能够将元素正确插入指定位置,并保持顺序表的有序性。

在删除操作中,能够按需删除指定位置或值的元素,并正确更新顺序表的长度。

在查找操作中,能够根据索引或值查找到对应的元素,并返回正确的结果。

在修改操作中,能够按需修改指定位置或值的元素,并更新顺序表的内容。

6. 实验总结本实验通过对顺序表的基本操作和实现方法的学习和实践,进一步巩固了对数据结构的理解和编程能力的培养。

顺序表作为一种常用的数据结构,对于解决实际问题具有重要的作用。

通过本次实验,我对顺序表的插入、删除、查找和修改等操作有了更深入的了解,并学会了如何实现这些操作。

通过本次实验,我还学会了顺序表的静态分配和动态分配方法,了解了它们的区别和适用场景。

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告一、实验目的本次实验的主要目的是通过实现顺序表的基本操作,深入理解线性表的逻辑结构和存储结构,掌握顺序表的插入、删除、查找等操作的实现方法,提高编程能力和问题解决能力。

二、实验环境本次实验使用的编程语言为 C 语言,编程环境为 Visual Studio 2019。

三、实验原理顺序表是一种线性表的存储结构,它使用一组连续的存储单元依次存储线性表中的元素。

在顺序表中,元素的逻辑顺序与物理顺序是一致的。

顺序表的基本操作包括初始化、插入、删除、查找、遍历等。

在实现这些操作时,需要考虑顺序表的存储空间是否已满、插入和删除元素时元素的移动等问题。

四、实验内容(一)顺序表的定义```cdefine MAXSIZE 100 //定义顺序表的最大长度typedef struct {int dataMAXSIZE; //存储顺序表的元素int length; //顺序表的当前长度} SeqList;```(二)顺序表的初始化```cvoid InitList(SeqList L) {L>length = 0;}```(三)顺序表的插入操作```cint InsertList(SeqList L, int i, int e) {if (L>length == MAXSIZE) {//顺序表已满return 0;}if (i < 1 || i > L>length + 1) {//插入位置不合法return 0;}for (int j = L>length; j >= i; j) {//移动元素L>dataj = L>dataj 1;}L>datai 1 = e; //插入元素L>length++;return 1;}```(四)顺序表的删除操作```cint DeleteList(SeqList L, int i, int e) {if (L>length == 0) {//顺序表为空return 0;}if (i < 1 || i > L>length) {//删除位置不合法}e = L>datai 1; //取出被删除的元素for (int j = i; j < L>length; j++){//移动元素L>dataj 1 = L>dataj;}L>length;return 1;}```(五)顺序表的查找操作```cint SearchList(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}}```(六)顺序表的遍历操作```cvoid TraverseList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```五、实验步骤1、打开 Visual Studio 2019,创建一个新的 C 语言项目。

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

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

课程设计报告问题描述:(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)程序的关键是掌握文件的相关操作、哈希函数的创建和运用、处理冲突的方法等。

散列表实验报告

散列表实验报告

课程名称:数据结构实验项目:散列表题目:散列表实验一、需求分析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:。

散列表的设计与实现报告

散列表的设计与实现报告

数据结构课程设计题目:散列表的设计与实现专业:计算机科学与技术指导教师:李竹林姓名:刘朋飞(1060309014004)何伟(1060309014042)输出记录开始进入录入系统获得关键字key用Hash1(key)计算地址比较nam_2(d)的值是否和关键字相等用探查序列d+i*hash2(key)计算(寻找)散列地址比较nam_Ht(d)的值是否和关键字相等未找到记录结束处理流程图3.功能模块设计:⑴.运用main函数输出电话本信息系统的整体界面,在调试运行后如下:⑵.利用添加功能 void getin(Record* a)实现用户信息的录入,在调试运行后如下:⑷.利用哈希函数CREA TEHASH1.2来构造哈希表并用Status collision函数的相应功能来查找并解决冲突:⑸.利用void SearchHash1(HashTable*H,int&c)在通讯录里查找姓名关键字,若查找成功,显示信息,c用来记录冲突次数,查找成功时显示冲突次数:三、详细设计与实现部分:定义头文件及基本属性#include<stdio.h>#include<iostream.h>#include<stdlib.h>#include<string>#include <windows.h>#define MAXSIZE20//电话薄记录数量#define MAX_SIZE 20 //人名的最大长度#define HASHSIZE 53 //定义表长#define SUCCESS 1#define UNSUCCESS -1#define LEN sizeof(HashTable)typedef int Status;typedef char NA[MAX_SIZE];定义结构体typedef struct{//记录NA name;NA tel;NA add;}Record;typedef struct{//哈希表Record *elem[HASHSIZE]; //数据元素存储基址int count; //当前数据元素个数int size; //当前容量}HashTable;关键字比较功能的实现Status eq(NA x,NA y){//关键字比较,相等返回 SUCCESS;否则返回 UNSUCCESSif(strcmp(x,y)==0)return SUCCESS;else return UNSUCCESS;}记录个数功能的实现Status NUM_BER; //记录的个数输入信息功能void getin(Record* a){//键盘输入各人的信息cout<<"输入要添加的个数:\n";cin>>NUM_BER;int i;for(i=0;i<NUM_BER;i++){cout<<"请输入第"<<i+1<<"个记录的用户名:\n";cin>>a[i].name;cout<<"请输入第"<<i+1<<"个记录的电话号码:\n";cin>>a[i].tel;cout<<"请输入第"<<i+1<<"个记录的地址:\n";cin>>a[i].add; //gets(str2);??????}}显示输入信息的实现void ShowInformation(Record* a)//显示输入的用户信息{int i;for( i=0;i<NUM_BER;i++)cout<<"\n 第"<<i+1<<"个用户信息:\n 姓名:"<<a[i].name<<"\n 电话号码:"<<a[i]. tel<<"\n联系地址:"<<a[i].add<<"\n";}清屏功能的实现void Cls(Record* a){cout<<"*";system("cls");}long fold(NA s){//人名的折叠处理char *p;long sum=0;NA ss;strcpy(ss,s);//复制字符串,不改变原字符串的大小写strupr(ss);//将字符串 ss 转换为大写形式p=ss;while(*p!='\0')sum+=*p++;cout<<"\nsum===================="<<sum;return sum;}构造哈希函数int Hash1(NA str){//哈希函数long n;int m;n=fold(str);//先将用户名进行折叠处理m=n%HASHSIZE; //折叠处理后的数,用除留余数法构造哈希函数return m; //并返回模值}int Hash2(NA str){//哈希函数long n;int m;n = atoi(str);//把字符串转换成整型数.m=n%HASHSIZE; //用除留余数法构造哈希函数return m; //并返回模值}冲突处理函数,用于解决冲突Status 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;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 benGetTime();void CreateHash1(HashTable* H,Record* a){//建表,以人的姓名为关键字,建立相应的散列表benGetTime();int i,p=-1,c,pp;for(i=0;i<NUM_BER;i++){c=0;p=Hash1(a[i].name);pp=p;while(H->elem[pp]!=NULL) {pp=collision(p,c);if(pp<0){cout<<"第"<<i+1<<"记录无法解决冲突";//需要显示冲突次数时输出continue;}//无法解决冲突,跳入下一循环}H->elem[pp]=&(a[i]);//求得哈希地址,将信息存入H->count++;cout<<"第"<<i+1<<"个记录冲突次数为"<<c<<".\n";//需要显示冲突次数时输出}cout<<"\n 建表完成!\n 此哈希表容量为"<<HASHSIZE<<",当前表内存储的记录个数为"<<H- >count<<".\n";benGetTime();}查找功能的实现void SearchHash1(HashTable* H,int &c){//在通讯录里查找姓名关键字,若查找成功,显示信息benGetTime();NA str;cout<<"\n 请输入要查找记录的姓名:\n";cin>>str;int p,pp;p=Hash1(str);pp=p;while((H->elem[pp]!=NULL)&&(eq(str,H->elem[pp]->name)==-1))pp=collision(p,c);if(H->elem[pp]!=NULL&&eq(str,H->elem[pp]->name)==1){cout<<"\n 查找成功!\n 查找过程冲突次数为"<<c<<".以下是您需要要查找的信息:\n\n"; cout<<"姓名:"<<H->elem[pp]->name<<"\n 电话号码:"<<H->elem[pp]->tel<<"\n 联系地址:"<<H->elem[pp]->add<<"\n";}else cout<<"\n 此人不存在,查找不成功!\n";benGetTime();}void benGetTime(){SYSTEMTIME sys;GetLocalTime( &sys );out<<sys.wYear<<sys.wMonth<<sys.wDay<<sys.wHour<<sys.wMinute<<sys.wSecond<<sys.wMi lliseconds;}void CreateHash2(HashTable* H,Record* a){//建表,以电话号码为关键字,建立相应的散列表benGetTime();int i,p=-1,c,pp;for(i=0;i<NUM_BER;i++){c=0;p=Hash2(a[i].tel);pp=p;while(H->elem[pp]!=NULL) {pp=collision(p,c);if(pp<0){cout<<"第"<<i+1<<"记录无法解决冲突";//需要显示冲突次数时输出continue;}//无法解决冲突,跳入下一循环}H->elem[pp]=&(a[i]);//求得哈希地址,将信息存入H->count++;cout<<"第"<<i+1<<"个记录冲突次数为"<<c<<"。

顺序表的查找插入与删除实验报告

顺序表的查找插入与删除实验报告

顺序表的查找插入与删除实验报告顺序表的查找、插入与删除实验报告《数据结构》实验报告一学院:班级:姓名:程序名学号:日期:一、上机实验的问题和要求:顺序表的搜寻、填入与删掉。

设计算法,同时实现线性结构上的顺序表的产生以及元素的搜寻、填入与删掉。

具体内容同时实现建议:1.从键盘输入10个整数,产生顺序表,并输入结点值。

2.从键盘输入1个整数,在顺序表搜寻该结点的边线。

若找出,输入结点的边线;若打听不到,则显示“找不到”。

3.从键盘输入2个整数,一个则表示欲填入的边线i,另一个则表示欲填入的数值x,将x挂入在对应位置上,输出顺序表所有结点值,观察输出结果。

4.从键盘输入1个整数,表示欲删除结点的位置,输出顺序表所有结点值,观察输出结果。

二、源程序及注解:#include#include/*顺序表的定义:*/#include#definelistsize100/*表空间大小可根据实际需要而定,这里假设为100*/typedefintdatatype;/*datatype可以是任何相应的数据类型如int,float或char*/typedefstruct{datatypedata[listsize];/*向量data用作放置表中结点*/intlength;/*当前的表中长度*/}seqlist;voidmain(){seqlistl;inti,x;intn=10;/*欲建立的顺序表长度*/l.length=0;voidcreatelist(seqlist*l,intn);voidprintlist(seqlistl,intn);intlo catelist(seqlistl,datatypex);voidinsertlist(seqlist*l,datatypex,inti);voiddele telist(seqlist*l,inti);1createlist(&l,n);/*建立顺序表*/printlist(l,n);/*打印顺序表*/printf(\输入要查找的值:\scanf(\i=locatelist(l,x);/*顺序表查找*/printf(\输入要插入的位置:\scanf(\printf(\输入要插入的元素:\scanf(\insertlist(&l,x,i);/*顺序表插入*/printlist(l,n);/*打印顺序表*/printf(\输入要删除的位置:\scanf(\deletelist(&l,i);/*顺序表删除*/printlist(l,n);/*打印顺序表*/}/*顺序表的创建:*/voidcreatelist(seqlist*l,intn){inti;for(i=0;ilength=n;}/*顺序表的列印:*/voidprintlist(seqlistl,intn){inti;for(i=0;i/*顺序表的查找:*/intlocatelist(seqlistl,datatypex){inti=0;while(iif(i2/*顺序表的插入:*/voidinsertlist(seqlist*l,datatypex,inti){intj;if(i<1||i>l->length+1){printf(\插入位置非法\\n\exit(0);}if(l->length>=listsize){printf(\表空间溢出,退出运行\\n\exit(0);}for(j=l->length-1;j>=i-1;j--)l->data[j+1]=l->data[j];l->data[i-1]=x;l->length++;}/*顺序表的删除:*/voiddeletelist(seqlist*l,inti){intj;if(l->length==0){printf(\现行表为空,退出运行\\n\exit(0);}if(i<1||i>l->length){printf(\删除位置非法\\n\exit(0);}for(j=i;j<=l->length-1;j++)l->data[j-1]=l->data[j];l->length--;}3三、运行输出结果:四、调试和运行程序过程中产生的问题及采取的措施:4。

数据结构-顺序表的查找实验报告

数据结构-顺序表的查找实验报告

计算机科学与技术系实验报告专业名称计算机科学与技术课程名称《数据结构》项目名称顺序表查找班级学号姓名同组人员无实验日期一、实验目的与要求:(简述本次实验要求达到的目的,涉及到的相关知识点,实验的具体要求。

)(一)实验目的:应用顺序表来实现对数据的查找(二)实验要求:用顺序表实现对数据进行查找(三)实验环境:VC++6.0.二、实验内容#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define ERROR 0#define OK 1#define INIT_SIZE 5 /*初始分配的顺序表长度*/#define INCREM 5 /*溢出时,顺序表长度的增量*/ typedef int ElemType; /*定义表元素的类型*/typedef struct Sqlist{ElemType *slist; /*存储空间的基地址*/int length; /*顺序表的当前长度*/int listsize; /*当前分配的存储空间*/}Sqlist;int InitList_sq(Sqlist *L);int CreateList_sq(Sqlist *L,int n);int ListInsert_sq(Sqlist *L,int i,ElemType e);int PrintList_sq(Sqlist *L);int ListDelete_sq(Sqlist *L,int i);int ListLocate(Sqlist *L,ElemType e);//初始化顺序表int InitList_sq(Sqlist *L){L->slist=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType));if(!L->slist) return ERROR;L->length=0;L->listsize=INIT_SIZE;return OK;}/*InitList*///创建顺序表int CreateList_sq(Sqlist *L,int n){ElemType e;int i;for(i=0;i<n;i++){printf("input data %d",i+1);printf(": ");scanf("%d",&e);if(!ListInsert_sq(L,i+1,e))return ERROR;}return OK;}/*CreateList*//*输出顺序表中的元素*/int PrintList_sq(Sqlist *L){int i;for(i=1;i<=L->length;i++)printf("%-5d",L->slist[i-1]);printf("\n");return OK;}/*PrintList*///在顺序表中插入int ListInsert_sq(Sqlist *L,int i,ElemType e){ int k;if(i<1||i>L->length+1)return ERROR;if(L->length>=L->listsize){L->slist=(ElemType*)realloc(L->slist,(INIT_SIZE+INCREM)*sizeof(ElemType));if(!L->slist)return ERROR;L->listsize+=INCREM;}for(k=L->length-1;k>=i-1;k--){L->slist[k+1]=k;}L->slist[i-1]=e;L->length++;return OK;}/*ListInsert*//*在顺序表中删除第i个元素*/int ListDelete_sq(Sqlist *L,int i){int j;if(L->length<0){printf("顺序表为空!\n");return ERROR;}else if(i < 0 || (i > L->length)){printf("i 的参数出错!\n");return ERROR;}else{for(j = i; j <= L->length; j ++) L->slist[j-1] = L->slist[j];L->length--;return OK;}}/*在顺序表中查找指定值元素,返回其序号*/int ListLocate(Sqlist *L,ElemType e){int i, z = 0;for(i = 0; i < L->length; i ++){if(L->slist[i] == e){printf("查找的元素%d 在第%d 位置\n", e, i+1);z = 1;//return OK;}}printf("没有查找到相应的数\n");return ERROR;}//主函数int main(){Sqlist sl;int n, i;ElemType e;printf("请创建表,输入顺序表的元素个数:"); /*输入顺序表的元素个数*/scanf("%d",&n);if(n>0){printf("\n1-Create Sqlist:\n");InitList_sq(&sl);CreateList_sq(&sl,n);printf("\n2-Print Sqlist:\n");PrintList_sq(&sl);system("cls");}elseprintf("ERROR");printf("---------------------------请选择操作方式--------------------------\n");printf("\t 1: 查找\t 2:删除\t 3: 输出表\t 0: 退出\n 输入操作数:");scanf("%d", &n);while(n){printf("\n链表元素:\n");PrintList_sq(&sl);if(n == 1){printf("\n请输入想要查找的元素:");scanf("%d", &e);ListLocate(&sl,e);}if(n == 2){printf("\n请输入想要删除元素的位置:");scanf("%d", &i);ListDelete_sq(&sl, i);}if(n == 3){printf("\n链表元素:\n");PrintList_sq(&sl);}printf("\t---------------------------请选择操作方式--------------------------");printf("\t 1: 查找\t 2:删除\t 0: 退出\n 输入操作数:");scanf("%d", &n);}return 0;}三、实验分析与小结(实验过程中的问题分析、产生的原因以及解决方法;实验结果分析;有待优化思路)(一)实验结果截图.(二)总结通过顺序表数组元素的特点,我们可以对数据实现顺序查找。

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

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

散列表的设计实验报告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;}。

顺序查找的实训报告

顺序查找的实训报告

一、实训目的本次实训旨在通过实践操作,掌握顺序查找的基本原理和方法,熟悉顺序查找在解决实际问题中的应用,并提高对数据结构中查找算法的理解和运用能力。

二、实训内容1. 理解顺序查找的基本概念和原理。

2. 编写顺序查找的算法实现。

3. 利用顺序查找算法解决实际问题。

4. 分析顺序查找的效率。

三、实训步骤1. 理论学习首先,通过查阅资料和课堂讲解,了解了顺序查找的基本概念。

顺序查找是一种基本的查找算法,它的工作原理是从线性表的第一个元素开始,逐个比较,直到找到要查找的元素或者查找完整个线性表。

2. 算法实现根据顺序查找的原理,编写了以下伪代码:```function sequentialSearch(arr, x):for i from 0 to length(arr) - 1:if arr[i] == x:return ireturn -1```3. 代码调试将伪代码转换为实际编程语言(如Python)的代码,并进行调试,确保算法的正确性。

```pythondef sequential_search(arr, x):for i in range(len(arr)):if arr[i] == x:return ireturn -1# 测试代码array = [5, 3, 7, 2, 8, 6, 1]target = 7result = sequential_search(array, target)print("元素位置:", result)```4. 测试与分析使用不同的测试数据对顺序查找算法进行测试,分析其性能。

- 测试数据1:已排序数组```array = [1, 2, 3, 4, 5, 6, 7, 8, 9]target = 7result = sequential_search(array, target)print("元素位置:", result)```- 测试数据2:未排序数组```array = [5, 3, 7, 2, 8, 6, 1]target = 7result = sequential_search(array, target)print("元素位置:", result)```5. 效率分析通过对比不同数据规模下的查找时间,分析了顺序查找的效率。

顺序表的操作实验报告

顺序表的操作实验报告

顺序表的操作实验报告一、实验目的。

1. 了解顺序表的基本概念和操作方法;2. 掌握顺序表的插入、删除、查找等操作;3. 熟悉顺序表的存储结构和实现方式。

二、实验内容。

1. 实现顺序表的基本操作,包括插入、删除、查找等;2. 对比顺序表和链表的优缺点;3. 分析顺序表的存储结构和实现方式。

三、实验原理。

顺序表是一种线性表的存储结构,它的特点是元素之间的逻辑顺序和物理顺序一致,即在内存中连续存储。

顺序表的基本操作包括插入、删除、查找等。

1. 插入操作,在顺序表的某个位置插入一个元素,需要将插入位置后的所有元素向后移动一个位置,然后将新元素插入到指定位置。

2. 删除操作,删除顺序表中的某个元素,需要将删除位置后的所有元素向前移动一个位置,然后将最后一个元素删除。

3. 查找操作,在顺序表中查找某个元素,需要遍历整个顺序表,逐个比较元素的值,直到找到目标元素或者遍历完整个表。

四、实验步骤。

1. 实现顺序表的基本操作,包括插入、删除、查找等;2. 编写测试用例,验证顺序表的功能和正确性;3. 对比顺序表和链表的优缺点,分析其适用场景;4. 分析顺序表的存储结构和实现方式,总结其特点和应用场景。

五、实验结果与分析。

1. 实现了顺序表的基本操作,包括插入、删除、查找等,功能正常;2. 经过测试用例验证,顺序表的功能和正确性得到了验证;3. 对比顺序表和链表的优缺点,发现顺序表的插入、删除操作效率较低,但查找操作效率较高,适合静态查找;4. 分析顺序表的存储结构和实现方式,发现其适用于元素数量较少且频繁查找的场景。

六、实验总结。

通过本次实验,我们深入了解了顺序表的基本概念和操作方法,掌握了顺序表的插入、删除、查找等操作。

同时,我们对比了顺序表和链表的优缺点,分析了顺序表的存储结构和实现方式,加深了对顺序表的理解和应用。

在今后的学习和工作中,我们将根据实验结果的分析,合理选择顺序表或链表作为数据结构,以满足不同场景下的需求。

实验报告 顺序表实验

实验报告 顺序表实验

《数据结构》实验报告1.上机题目:顺序表实验2.需求分析实现顺序表的建立、输出、查找、插入、删除、合并几项功能。

明确说明程序的开发环境和功能要求。

针对主要功能,给出如下说明:(1)输入参数的格式和合法取值范围输入参数范围输入格式菜单选择数字 0—6, getche()接受键盘上对应的按钮数据输入 0—9999 scanf(“%s”,data)程序是否执行 y n getche()接受键盘上对应按键(2)输出的格式输出参数输出格式文字输出 printf(“******”);数据输出 printf(“%d”,data[i])(3)测试数据能够完成顺序表的建立、输出、查找、插入、删除、合并几项功能。

********************************* 1.建立一个顺序表 ** 2.输出一个顺序表 ** 3.在顺序表中查找 ** 4.向顺序表中插入一个元素 ** 5.删除顺序表中的一个元素 ** 6.将两个顺序表合并 ** 0.退出 *********************************(4)开发环境Vc6.03.详细设计(1)确定存储结构,并给出所用数据类型的数据结构定义采用顺序表存储的线性表。

利用内存中的一片起始位置确定的连续存储区域来存放表中的所以元素。

可以根据需要对表中的任何数据元素进行访问,元素的插入,删除可以在表中任何位置进行。

typedef struct {ElemType data[MAXSIZE];int length;}SqList;(2)给出所用数据类型中每个操作的伪码算法A.初始化建立的顺序表Void InitList(SqList &L)置 L.length 为 0B.建立新的顺序表Void CreatSqlist(SqList &L,int n)开辟一个数据结构空间,容量是MAXSIZEif str 是四位正整数记录else重新输入正确值C.输出顺序表int Output(SqList L)if L.length 等于 0return 0elsereturn 1D. 在顺序表中按位置取值int GetElem(SqList L,int i)if 取值不在线性表范围内return -9999;elsereturn L.data[i];E.在顺序表中按位置取值int LocateElem(SqList L,ElemType x)While x=L.data[k]if(k<L.length)return k;elsereturn -1;F.在i处插入元素int Insert(SqList &L,ElemType x,int i)if 不在k的范围内插入return 0;else在 i处插入元素return 1;G.在i处删除元素int Delete(SqList &L,int i)if i不在L.length范围内return 0;else删除i处的元素return 1;H. 合并la lb两个顺序表Void MergeList(SqList la,SqList lb,SqList &lc) la,lb升序排序la先存在lclb再存在lc4.调试分析(1)调试过程中主要遇到哪些问题?是如何解决的?A.在程序结束时如果按书上的代码printf("继续执行吗Y(1)/N(0): ");scanf("%d",&k);if(!k)return;只要不输入0都会继续执行代码,所以我想让此时的程序只识别 y 和 n 两个按键通过查找 y的键盘值是 0x0079N的键盘值是 0x006e通过 key=getche(),判断key的值来决定标志位的值来。

散列表实验报告doc

散列表实验报告doc

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

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

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

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

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

该符号表常采用散列表。

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

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

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

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

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

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

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

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

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

测试数据输入:4aansandhellocppaban。

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

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

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

实验实现
#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.掌握了为数组排序的方法。

3.正确理解for循环与数组的共同使用方式
4.会灵活的使用函数。

相关文档
最新文档