数据结构实验七 查找

合集下载

数据结构 查找 实验报告

数据结构 查找 实验报告

数据结构查找实验报告数据结构查找实验报告1·实验目的本实验旨在研究不同的查找算法在不同数据结构下的性能表现,通过实验结果对比分析,选取最优算法来完成查找操作。

2·实验方法2·1 数据结构选择在本实验中,我们选择了常用的数据结构进行查找性能比较,包括线性表、二叉树、哈希表等。

2·2 查找算法选择我们选择了以下常用的查找算法进行实验:●顺序查找●二分查找●插值查找●二叉查找树●平衡二叉查找树(AVL树)●哈希查找3·实验过程3·1 实验环境设置首先,我们需要搭建合适的实验环境,包括编程语言选择、编译器、开发环境等。

在本次实验中,我们选择了C++编程语言,并使用了Visual Studio 2019作为开发环境。

3·2 实验步骤为了比较各个查找算法的性能,我们按照以下步骤进行实验: 1·创建用于查找的数据结构,并初始化数据集合。

2·调用每个查找算法进行查找,并记录查找耗时。

3·分析实验结果,比较各个查找算法的性能。

4·实验结果与分析根据实验步骤中记录的各个查找算法的耗时,我们得到了以下结果:●对于小规模数据集,顺序查找表现较好。

●对于有序数据集,二分查找和插值查找表现最佳。

●对于动态数据集,哈希表的查找效率最高。

5·结论根据实验结果与分析,我们得出以下结论:●不同的数据结构适用于不同的查找需求。

●在静态有序数据集中,二分查找和插值查找是较好的选择。

●在动态数据集中,哈希表具有较高的查找效率。

附件:附件1:实验数据集附件2:查找算法代码法律名词及注释:1·数据结构:数据之间的组织方式和关系,使得我们可以高效地进行数据的存储和操作。

2·查找算法:在给定某个目标值的情况下,在给定数据集内寻找目标值的算法。

3·顺序查找:逐个比较目标值和数据集内的元素,直到找到目标值或者遍历完整个数据集。

数据结构实验七 查找

数据结构实验七 查找

数据结构实验七查找数据结构实验七查找一、实验目的本实验旨在通过实际操作和编程实现不同查找算法,并对其进行性能比较。

二、实验内容1.线性查找算法2.二分查找算法3.插值查找算法4.哈希查找算法三、线性查找算法线性查找算法是最简单的查找算法之一,它的基本思想是从第一个元素开始逐个比较,直到找到目标元素或遍历完整个数组。

1.算法步骤:●从数组的第一个元素开始遍历,比较当前元素与目标元素是否相等。

●如果相等,则查找成功,返回当前元素的索引。

●如果不相等,继续遍历下一个元素,重复上述步骤,直到遍历完整个数组。

●如果遍历完数组仍未找到目标元素,则查找失败,返回.1.2.算法示例代码(Python):```def linear_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn .1```四、二分查找算法二分查找算法适用于有序数组,它通过每次将目标值与数组的中间元素进行比较,并根据比较结果缩小搜索范围。

1.算法步骤:●初始化左边界为数组的第一个元素的索引,右边界为数组的最后一个元素的索引。

●在每一次循环中,找到数组中间元素的索引(mid)。

●将目标值与中间元素进行比较:●如果相等,则查找成功,返回中间元素的索引。

●如果目标值大于中间元素,则说明目标值在中间元素的右侧,将左边界更新为mid + 1.●如果目标值小于中间元素,则说明目标值在中间元素的左侧,将右边界更新为mid ●1.●重复上述步骤,直到左边界大于右边界,表示查找失败。

2.算法示例代码(Python):```def binary_search(arr, target):left = 0right = len(arr) ●1while left <= right:mid = (left + right) // 2if arr[mid] == target:return midelif arr[mid] < target:left = mid + 1else:right = mid ●1return .1```五、插值查找算法插值查找算法是对二分查找算法的改进,它通过根据目标值在数组中的分布情况,更准确地预测目标值的位置,从而提高查找效率。

数据结构实验七 查找

数据结构实验七 查找

数据结构实验七查找数据结构实验七查找一、实验目的本实验旨在通过编程实现常见的查找算法,包括顺序查找、二分查找和哈希查找,并比较它们的效率和适用场景。

二、实验内容1.顺序查找1.1 算法思想顺序查找算法是一种简单直观的查找方法,它的基本思想是从数组的第一个元素开始逐个比较,直到找到目标元素或遍历完整个数组。

1.2 算法流程a) 初始化目标元素的索引为 -1.b) 从数组的第一个元素开始,依次与目标元素比较。

c) 如果找到目标元素,则记录其索引,并结束查找。

d) 如果遍历完整个数组仍未找到目标元素,则记录目标索引仍为 -1.1.3 时间复杂度顺序查找算法的时间复杂度为 O(n),其中 n 为数组的长度。

2.二分查找2.1 算法思想二分查找算法是一种高效的查找算法,但要求被查找的数组必须是有序的。

它的基本思想是将目标元素与数组的中间元素进行比较,然后根据比较结果将查找的范围缩小一半,直到找到目标元素或查找范围为空。

2.2 算法流程a) 初始化目标元素的索引为 -1、查找范围的起始索引为0,终止索引为数组长度减一。

b) 计算查找范围的中间索引,取整数部分。

c) 将目标元素与中间索引对应的数组元素进行比较:- 如果相等,则记录中间索引为目标索引,并结束查找。

- 如果目标元素小于中间元素,则在前一半查找范围中进行二分查找。

- 如果目标元素大于中间元素,则在后一半查找范围中进行二分查找。

d) 如果查找范围的起始索引大于终止索引,则表示查找范围为空,记录目标索引仍为 -1.2.3 时间复杂度二分查找算法的时间复杂度为 O(log n),其中 n 为数组的长度。

3.哈希查找3.1 算法思想哈希查找算法利用哈希函数将关键字映射到一个固定位置进行查找,从而实现快速访问。

它的基本思想是通过哈希函数计算得到关键字的哈希值,并根据哈希值找到对应的存储位置,如果哈希表中已经存在该关键字,则返回对应的值,否则返回空。

3.2 算法流程a) 初始化一个哈希表,用于存储关键字和对应值的映射。

王道数据结构 第七章 查找思维导图-高清脑图模板

王道数据结构 第七章 查找思维导图-高清脑图模板

每次调整的对象都是“最小不平衡子树”
插入操作
在插入操作,只要将最小不平衡子树调整平衡,则其他祖先结点都会恢复平衡
在A的左孩子的左子树中插入导致不平衡
由于在结点A的左孩子(L)的左子树(L)上插入了新结点,A的平衡因子由1增
至2,导致以A为根的子树失去平衡,需要一次向右的旋转操作。
LL
将A的左孩子B向右上旋转代替A成为根节点 将A结点向右下旋转成为B的右子树的根结点
RR平衡旋转(左单旋转)
而B的原左子树则作为A结点的右子树
在A的左孩子的右子树中插入导致不平衡
由于在结点A的左孩子(L)的右子树(R)上插入了新结点,A的平衡因子由1增
LR
至2,导致以A为根的子树失去平衡,需要两次旋转操作,先左旋转再右旋转。
将A的左孩子B的右子树的根结点C向左上旋转提升至B结点的位置
本质:永远保证 子树0<关键字1<子树1<关键字2<子树2<...
当左兄弟很宽裕时,用当前结点的前驱、前驱的前驱来填补空缺 当右兄弟很宽裕时,用当前结点的后继、后继的后继来填补空缺
兄弟够借。若被删除关键字所在结点删除前的关键字个数低于下限,且与此结点 右(或左)兄弟结点的关键字还很宽裕,则需要调整该结点、右(或左)兄弟结 点及其双亲结点及其双亲结点(父子换位法)
LL平衡旋转(右单旋转)
而B的原右子树则作为A结点的左子树
在A的右孩子的右子树中插入导致不平衡
由于在结点A的右孩子(R)的右子树(R)上插入了新结点,A的平衡因子由-1
减至-2,导致以A为根的子树失去平衡,需要一次向左的旋转操作。
RR
将A的右孩子B向左上旋转代替A成为根节点 将A结点向左下旋转成为B的左子树的根结点

数据结构查找实验报告

数据结构查找实验报告

一、实验目的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)。

数据结构-7顺序查找与二分查找

数据结构-7顺序查找与二分查找

i=m+1=8,j=8, m=(i+j)/2=8。 r[m]>k : 在左半部分继续查找。
i=8, j=m-1=7 ,
i>j: 查找失败
存储结构
key info 0 1 k1 2 k2 3 k3
…………
n kn
typedef struct { keytype key; ………….
} elemtype;
分块有序表的结构可以分为两部分: 1、线性表本身是顺序存储结构 2、再建立一个索引表,线性表中每个子表建立一个索引节点
。索引节点包括两部分:一是数据域,一是指针域。数据域存 放对应子表中的最大元素值,指针域用于指示子表第一个元素 的在整个表中序号。
分块查找
template<class T> struct indnode {
key=32
d (1) 27
i=1
d (2) 36
i=2
d (3) 32i=3 Nhomakorabead (4) 18
此时d(i)=key,数组中的第3个位置
如果输入查找的元素值key=22
d (1) 27 i=1
d (2) 36 i=2
d (3) 32 i=3
d (4) 18
i=4 i=5 此时i等于5,超过数组中元素个数,找不到
T key; int k; };
上图查找过程:首先查找索引表,确定查找的子表,然后再相应的子表中 应顺序表查找法查找。
• int blksearch(record r[],index idx[],keytype key)
•{
• int i=0,j;
• while(i<idxN)
•{
• if(key<=idx[i].key){

数据结构实验七 查找

数据结构实验七 查找

数据结构实验七查找在计算机科学中,数据结构是组织和存储数据的方式,而查找则是在给定的数据结构中寻找特定元素的操作。

本次实验七的重点就是深入研究查找这一重要的数据处理操作。

查找操作在我们日常生活和计算机程序中无处不在。

想象一下在电话簿中查找一个朋友的号码,或者在图书馆的书架中寻找一本书,这都是查找的实际应用场景。

在计算机程序中,当我们需要从大量数据中快速找到所需的信息时,高效的查找算法就显得至关重要。

常见的查找算法有顺序查找、二分查找、哈希查找等。

顺序查找是最简单直接的方法,它从数据结构的起始位置开始,依次比较每个元素,直到找到目标元素或者遍历完整个数据结构。

这种方法适用于数据量较小或者数据未排序的情况。

让我们通过一个简单的示例来理解顺序查找。

假设有一个整数数组5, 3, 8, 2, 9,我们要查找数字 8。

从数组的第一个元素 5 开始,依次与8 进行比较。

当比较到第三个元素时,找到了目标数字 8,查找结束。

虽然顺序查找的思路简单,但在数据量较大时,它的效率相对较低。

与顺序查找不同,二分查找则要求数据是有序的。

它通过不断将待查找的区间一分为二,逐步缩小查找范围,从而提高查找效率。

还是以整数数组为例,比如 2, 4, 6, 8, 10 要查找数字 6。

首先,比较中间元素 6 和目标数字 6,正好相等,查找成功。

如果要查找的数字小于中间元素,则在左半区间继续查找;如果大于中间元素,则在右半区间查找。

二分查找的效率在有序数据中表现出色。

然而,如果数据经常变动,需要频繁进行插入和删除操作,维护数据的有序性可能会带来较大的开销。

哈希查找则是另一种常见的查找方法。

它通过一个哈希函数将关键字映射到一个特定的位置,从而实现快速查找。

哈希函数的设计至关重要,如果设计不当,可能会导致大量的冲突,影响查找效率。

在实际应用中,选择合适的查找算法取决于多种因素,如数据的规模、数据的分布特征、查找的频繁程度以及对时间和空间复杂度的要求等。

数据结构 查找 实验报告

数据结构 查找 实验报告

数据结构查找实验报告数据结构查找实验报告1. 简介查找是计算机科学中一种常见的操作,它用于在一组数据中快速定位特定的元素。

数据结构是计算机存储、组织数据的方式,可以有效地支持查找操作。

本实验报告将介绍查找算法的原理和实现,以及实验结果的分析和总结。

2. 查找算法2.1 顺序查找顺序查找是一种简单直观的查找算法,它从数据集的第一个元素开始逐个比较,直至找到目标元素或遍历完所有元素。

顺序查找的时间复杂度为O(n),其中n是数据集的大小。

2.2 二分查找二分查找是一种高效的查找算法,它要求数据集必须是有序的。

它通过将数据集分成两部分,并与目标元素进行比较,以确定目标元素所在的区间,然后在该区间内继续二分查找,直至找到目标元素或确定目标元素不存在。

二分查找的时间复杂度为O(log n),其中n是数据集的大小。

2.3 插值查找插值查找是对二分查找的一种改进,它根据目标元素的估计位置来确定比较的起始位置。

它适用于数据集分布均匀的情况,可以进一步减少查找的次数。

插值查找的时间复杂度为O(log(log n))。

3. 实验结果本次实验我们使用了三种查找算法(顺序查找、二分查找和插值查找)在不同大小的数据集上进行了性能测试。

实验结果如下表所示:---- 数据集大小 ---- 顺序查找时间(ms) ---- 二分查找时间(ms) ---- 插值查找时间(ms) ---------------------------------------------------------------------------------------------- 1000 ---- 10 ---- 2 ---- 1 -------- 10000 ---- 100 ---- 4 ---- 2 -------- 100000 ---- 1000 ---- 6 ---- 3 -------- 1000000 ---- 10000 ---- 8 ---- 4 ----从实验结果可以看出,随着数据集的增大,顺序查找的时间成正比增加,而二分查找和插值查找的时间相对较稳定。

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

实验七查找一、实验目的1. 掌握查找的不同方法,并能用高级语言实现查找算法;2. 熟练掌握二叉排序树的构造和查找方法。

3. 熟练掌握静态查找表及哈希表查找方法。

二、实验内容设计一个读入一串整数,然后构造二叉排序树,进行查找。

三、实验步骤1. 从空的二叉树开始,每输入一个结点数据,就建立一个新结点插入到当前已生成的二叉排序树中。

2. 在二叉排序树中查找某一结点。

3.用其它查找算法进行排序(课后自己做)。

四、实现提示1. 定义结构typedef struct node{ int key;int other;struct node*lchild, *rchild;} bstnode;void inorder ( t ){ if(t!=Null){ inorder(t→lchild);printf(“%4d”, t→key);inorder(t→rchild);} }bstnode*insertbst(t, s)bstnode*s,*t;{ bstnode*f,*p;p=t;while(p!=Null){ f=p;if (s→key= =p→key)return t;if (s→key<p→key)p=p→lchild; elsep=p→rchild;}if(t= =Null)return s;if (s→key<f→key)f→lchild=s; elsef→rchild=s;return t;}bstnode*creatord(){ bstnode*t, * s;int key;t=Null;scanf(“%d”,&key);while (key!=0){ s=malloc(sizeof (bitree));s→key=key;s→lchild=Null;s→rchild=Null;scanf(“%d”, &data);s→other=data;t=insertbst(t, s);scanf(“%d”,&key);}return t;}五、思考与提高1. 用其它的查找方法完成该算法。

2.比较各种算法的时间及空间复杂度。

六、完整参考程序1.折半查找#include <conio.h>#include <stdio.h>#define MAX 30 //定义有序查找表的最大长度typedef struct{char elem[MAX]; //有序查找表int length; //length指示当前有序查找表的长度}SSTable;void initial(SSTable &); //初始化有序查找表int search(SSTable,int); //在有序查找表中查找元素void print(SSTable); //显示有序查找表中所有元素void main(){SSTable ST; //ST为一有序查找表int ch,loc,flag=1;initial(ST); //初始化有序查找表while(flag){ printf("请选择:\n");printf("1.显示所有元素\n");printf("2.查找一个元素\n");printf("3.退出\n");scanf(" %c",&j);switch(j){case '1':print(ST); break; //显示所有元素case '2':{printf("请输入要查找的元素:");scanf("%d",&ch); //输入要查找的元素的关键字loc=search(ST,ch); //查找if(loc!=0) printf("该元素所在位置是:%d\n",loc); //显示该元素位置else printf("%d 不存在!\n",ch);//当前元素不存在break;}default:flag=0;}printf("程序运行结束!按任意键退出!\n");}void initial(SSTable &v){//初始化有序查找表int i;printf("请输入静态表的元素个数:"); //输入有序查找表初始化时的长度scanf("%d",&v.length);printf("请从小到大输入%d个元素(整形数):\n",v.length);getchar();for(i=1;i<=v.length;i++) scanf("%d",&v.elem[i]); //从小到大输入有序查找表的各元素}int search(SSTable v,int ch){//在有序查找表中查找ch的位置,成功返回其位置,失败返回0int low,high,mid;low=1;high=v.length; //置区间初值while(low<=high){mid=(low+high)/2;if(v.elem[mid]==ch) return mid; //找到待查元素else if(v.elem[mid]>ch) high=mid-1; //继续在前半区间进行查找else low=mid+1; //继续在后半区间进行查找}return 0; //找不到时,i为0}void print(SSTable v) //显示当前有序查找表所有元素{int i;for(i=1;i<=v.length;i++) printf("%d ",v.elem[i]);printf("\n");}2.二叉排序树的建立与查找#include <conio.h>#include <math.h>#include <stdio.h>#include <stdlib.h>enum BOOL{False,True};typedef struct BiTNode //定义二叉树节点结构{char data; //为了方便,数据域只有关键字一项struct BiTNode *lchild,*rchild; //左右孩子指针域}BiTNode,*BiTree;BOOL SearchBST(BiTree,char,BiTree,BiTree&); //在二叉排序树中查找元素BOOL InsertBST(BiTree &,char); //在二叉排序树中插入元素BOOL DeleteBST(BiTree &,char); //在二叉排序树中删除元素void Delete(BiTree &); //删除二叉排序树的根结点void InorderBST(BiTree); //中序遍历二叉排序树,即从小到大显示各元素void main(){BiTree T,p;char ch,keyword,j='y';BOOL temp;T=NULL;while(j!='n'){printf("1.display\n");printf("2.search\n");printf("3.insert\n");printf("4.delete\n");printf("5.exit\n");scanf(" %c",&ch); //输入操作选项switch(ch){case '1':if(!T) printf("The BST has no elem.\n");else {InorderBST(T);printf("\n");}break;case '2':printf("Input the keyword of elem to be searched(a char):"); scanf(" %c",&keyword); //输入要查找元素的关键字temp=SearchBST(T,keyword,NULL,p);if(!temp) printf("%c isn't existed!\n",keyword); //没有找到else printf("%c has been found!\n",keyword); //成功找到break;case '3':printf("Input the keyword of elem to be inserted(a char):"); scanf(" %c",&keyword); //输入要插入元素的关键字temp=InsertBST(T,keyword);if(!temp) printf("%c has been existed!\n",keyword); //该元素已经存在else printf("Sucess to inert %c!\n",keyword); //成功插入break;case '4':printf("Input the keyword of elem to be deleted(a char):");scanf(" %c",&keyword); //输入要删除元素的关键字temp=DeleteBST(T,keyword);if(!temp) printf("%c isn't existed!\n",keyword); //该元素不存在else printf("Sucess to delete %c\n",keyword); //成功删除break;default: j='n';}}printf("The program is over!\nPress any key to shut off the window!\n"); getchar();getchar();}void InorderBST(BiTree T){//以中序方式遍历二叉排序树T,即从小到大显示二叉排序树的所有元素if(T->lchild) InorderBST(T->lchild);printf("%2c",T->data);if(T->rchild) InorderBST(T->rchild);}BOOL SearchBST(BiTree T,char key,BiTree f,BiTree &p){//在根指针T所指二叉排序树中递归的查找其关键字等于key的元素,若查找成功//则指针p指向该数据元素,并返回True,否则指针指向查找路径上访问的最后一//个结点并返回False,指针f指向T的双亲,其初始调用值为NULLBOOL tmp1,tmp2;tmp1=tmp2=False;if(!T) {p=f;return False;} //查找不成功else if(key==T->data) {p=T;return True;} //查找成功else if(key<T->data) tmp1=SearchBST(T->lchild,key,T,p); //在左子树中继续查找else tmp2=SearchBST(T->rchild,key,T,p); //在右子树中继续查找if(tmp1||tmp2) return True; //若在子树中查找成功,向上级返回Trueelse return False; //否则返回False}BOOL InsertBST(BiTree &T,char e){//当二叉排序树T中不存在元素e时,插入e并返回True,否则返回FalseBiTree p,s;if(!SearchBST(T,e,NULL,p)) //查找不成功{s=(BiTree)malloc(sizeof(BiTNode));s->data=e;s->lchild=s->rchild=NULL;if(!p) T=s; //被插结点*s为新的根结点else if(e<p->data) p->lchild=s; //被插结点*s为左孩子else p->rchild=s; //被插结点*s为右孩子return True; //成功插入}else return False; //树中已存在关键字为e的数据元素}BOOL DeleteBST(BiTree &T,char key){//若二叉排序树T中存在关键字等于key的数据元素时,则删除该数据元素结点//并返回True,否则返回FalseBOOL tmp1,tmp2;tmp1=tmp2=False;if(!T) return False; //不存在关键字等于key的数据元素else{if(key==T->data) {Delete(T); return True;}//找到关键字等于key的数据元素并删除它else if(key<T->data) tmp1=DeleteBST(T->lchild,key); //继续在左子树中删除else tmp2=DeleteBST(T->rchild,key); //继续在右子树中删除if(tmp1||tmp2) return True; //在子树中删除成功,返回Trueelse return False; //不存在该元素}}void Delete(BiTree &p){//在二叉排序树中删除结点p,并重接它的左或右子树BiTree s,q;if(!p->rchild) //右子树空,只需重接它的左子树{q=p;p=p->lchild;free(q);}else if(!p->lchild) //左子树空,只需重接它的右子树{q=p;p=p->rchild;free(q);}else //左右子树均不空{q=p;s=p->lchild;while(s->rchild){q=s;s=s->rchild;} //转左,然后向右走到尽头p->data=s->data; //s指向被删结点的“前驱”if(q!=p) q->rchild=s->rchild; //重接*q的右子树else q->lchild=s->lchild; //重接*q的左子树free(s);}}。

相关文档
最新文档