数据结构实验七 查找
数据结构 查找 实验报告

数据结构查找实验报告数据结构查找实验报告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顺序查找与二分查找

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.掌握顺序查找操作的算法实现。
二、实验平台操作系统:Windows7或Windows XP开发环境:JA V A三、实验内容及要求1.建立顺序查找表,并在此查找表上实现顺序查找操作。
四、实验的软硬件环境要求硬件环境要求:PC机(单机)使用的软件名称、版本号以及模块:Netbeans 6.5以上或Eclipse、MyEclipse等编程环境下。
五、知识准备前期要求掌握查找的含义和顺序查找操作的方法。
六、验证性实验1.实验要求编程实现如下功能:(1)根据输入的查找表的表长n和n个关键字值,建立顺序查找表,并在此查找表中用顺序查找方法查找给定关键值的记录,最后输出查找结果。
2. 实验相关原理:查找表分别静态查找表和动态查找表两种,其中只能做引用操作的查找表称为静态查找表。
静态查找表采用顺序存储结构,待查找的记录类可描述如下:public class RecordNode {private Comparable key; //关键字private Object element; //数据元素……}待排序的顺序表类描述如下:public class SeqList {private RecordNode[] r; //顺序表记录结点数组private int curlen; //顺序表长度,即记录个数// 顺序表的构造方法,构造一个存储空间容量为maxSize的顺序表public SeqList(int maxSize) {this.r = new RecordNode[maxSize]; // 为顺序表分配maxSize个存储单元this.curlen = 0; // 置顺序表的当前长度为0}……}【核心算法提示】查找操作是根据给定的某个值,在查找表中确定一个其关键字等于给定值的数据元素或记录的过程。
若查找表中存在这样一个记录,则称“查找成功”。
查找结果给出整个记录的信息,或指示该记录在查找表中的位置;若在查找表中不存在这样的记录,则称“查找不成功”。
数据结构查找实验报告

数据结构查找实验报告数据结构查找实验报告一、引言数据结构是计算机科学中的重要概念之一,它涉及到组织和管理数据的方式和方法。
在实际应用中,我们经常需要对大量的数据进行查找操作,因此查找算法的效率和准确性显得尤为重要。
本实验旨在通过对比不同的查找算法,探索其性能和适用场景。
二、实验目的本实验的目的是比较常见的查找算法,包括线性查找、二分查找和哈希查找,分析它们的时间复杂度和空间复杂度,并通过实验数据验证其效率。
三、实验方法1. 实验环境本实验使用C++语言进行编程,选择了Visual Studio作为开发环境,以保证实验结果的准确性和可靠性。
2. 实验步骤(1)线性查找线性查找是最简单直接的查找算法,它的原理是从头到尾逐个比较待查找元素和数组中的元素,直到找到目标元素或遍历完整个数组。
在实验中,我们随机生成一个包含一定数量元素的有序数组,并使用线性查找算法查找目标元素。
(2)二分查找二分查找是一种高效的查找算法,它基于有序数组的特点,通过不断缩小查找范围来快速定位目标元素。
在实验中,我们同样生成一个有序数组,并使用二分查找算法进行查找操作。
(3)哈希查找哈希查找是一种基于哈希表的查找算法,它通过将关键字映射到哈希表中的位置来实现快速查找。
在实验中,我们使用哈希查找算法对一个包含大量元素的数组进行查找。
四、实验结果与分析1. 时间复杂度通过实验数据统计,我们可以得到不同查找算法的平均时间复杂度。
线性查找的时间复杂度为O(n),其中n为数组的大小;二分查找的时间复杂度为O(logn),哈希查找的时间复杂度为O(1)。
可以看出,随着数据规模增大,二分查找和哈希查找的效率明显高于线性查找。
2. 空间复杂度线性查找的空间复杂度为O(1),即不需要额外的存储空间;二分查找的空间复杂度为O(1),哈希查找的空间复杂度为O(n),其中n为哈希表的大小。
因此,从空间复杂度的角度来看,线性查找和二分查找相对较优。
3. 实验结果通过多次实验,我们得到了不同查找算法的平均查找时间。
数据结构实验报告——查找与排序

哈尔滨工业大学(深圳)数据结构实验报告查找与排序学院: 计算机科学与技术一、问题分析此题是一道排序问题,排序的方法有很多种,此题我用的是堆排序,这是一种不稳定排序,但时间复杂度较低,比较快。
计算机首先需要把文件中的数据读入内存中,用动态数组存储数据,然后建立数据结构,然后建立堆,比较子节点和父节点大小,降序排列,之后互换头结点与尾节点,再递归重复即可。
查找的话,依次查找对比即可。
二、详细设计2.1 设计思想将股票的代码,交易日期,及开盘价等信息分别用不同的动态数组存储起来。
因为要根据交易量的降序进行排序所以应将交易量的信息另外用一个float型的数组保存起来便于比较。
排序:使用一个下标数组用来模拟交易量的堆排序,将下标数组进行降序排序。
再根据下标数组里的值将股票信息保存在新的文件中。
查看:因为录入文件时是先把股票的代码相同的信息存入数组的。
所以查找时比较股票的代码,找到该代码后比较交易日期。
最后输出交易量。
2.2 存储结构及操作(1) 存储结构(一般为自定义的数据类型,比如单链表,栈等。
)vector<string> a;//股票代码vector<string> b;//股票交易日期vector<string> c;//股票开盘价_最高价_最低价_收盘价vector<float> d;//将交易量转换为float用于比较不过有的会被舍去vector<string> e;//交易量的原始数据用于输出到排序的文件中(2)涉及的操作(一般为自定义函数,可不写过程,但要注明该函数的含义。
)read_file() 将文件信息分别保存在上述存储结构中HeapAdjust(vector<long>& x,long s,long n) 小顶堆的调整函数HeapSort() 用堆排序进行交易量的降序排序并存储在指定文件中serach() 查找某交易日期某股票的交易量2.3 程序整体流程开始 A读入文件,存入数组 B排序 C查找 D结束 E2.堆排序示意图(由于堆排序描述时需要具体数据,所以只弄到示意图)三、用户手册1>将股票文件先存入指定文件夹中,根据提示输入文件名字按回车即可2>先在指定文件夹新建你要保存的文件后将文件的名字输入3>根据提示输入股票代码及交易日期,以空格隔开。
数据结构实验报告七查找

云南大学软件学院数据结构实验报告(本实验项目方案受“教育部人才培养模式创新实验区(X3108005)”项目资助)实验难度: A □ B □ C □序号学号姓名成绩123指导教师(签名)学期:2010秋季学期任课教师:实验题目: 查找算法设计与实现姓名: 王辉学号: 20091120154电子邮件:完成提交时间: 2010 年 12 月 27 日云南大学软件学院2010学年秋季学期《数据结构实验》成绩考核表学号:姓名:本人承担角色:综合得分:(满分100分)指导教师:年月日(注:此表在难度为C时使用,每个成员一份。
)(下面的内容由学生填写,格式统一为,字体: 楷体, 行距: 固定行距18,字号: 小四,个人报告按下面每一项的百分比打分。
难度A满分70分,难度B满分90分)一、【实验构思(Conceive)】(10%)1 哈希表查找。
根据全年级学生的姓名,构造一个哈希表,选择适当的哈希函数和解决冲突的方法,设计并实现插入、删除和查找算法。
熟悉各种查找算法的思想。
2、掌握查找的实现过程。
3、学会在不同情况下运用不同结构和算法求解问题。
4 把每个学生的信息放在结构体中:typedef struct //记录{NA name;NA tel;NA add;}Record;5 void getin(Record* a)函数依次输入学生信息6 人名折叠处理,先将用户名进行折叠处理折叠处理后的数,用除留余数法构造哈希函数,并返回模值。
并采用二次探测再散列法解决冲突。
7姓名以汉语拼音形式,待填入哈希表的人名约30个,自行设计哈希函数,用线性探测再散列法或链地址法处理冲突;在查找的过程中给出比较的次数。
完成按姓名查询的操作。
将初始班级的通讯录信息存入文件。
二、【实验设计(Design)】(20%)(本部分应包括:抽象数据类型的功能规格说明、主程序模块、各子程序模块的伪码说明,主程序模块与各子程序模块间的调用关系)1抽象数据类型的功能规格说明和结构体:#include<stdio.h>#include<stdlib.h>#include<string>#include <windows.h>#define MAXSIZE 20 //电话薄记录数量#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;2 主函数与各子函数的调用关系:(通过switch(num)函数按不同功能要求分别调用相关函数)int main(int argc, char* argv[]){system("color 61");int c,flag=1;HashTable *H;H=(HashTable*)malloc(LEN);for(int i=0;i<HASHSIZE;i++)H->elem[i]=NULL;H->size=HASHSIZE;H->count=0;Record a[MAXSIZE];while (1){printf("\n ★☆★☆★☆★☆★☆wang hui★☆★☆★☆★☆★☆★☆");printf("\n ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★");printf("\n ★☆★☆我的未来不是梦★☆★☆");printf("\n ★☆★☆无聊中郁闷死★☆★☆");printf("\n ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★");printf("\n ┏━━━━━━━━━━━━━┓");printf("\n ★┃欢迎欢迎欢迎欢迎欢迎欢迎┃★");printf("\n 〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓"); printf("\n ★★★★★★★哈希表的设计与实现★★★★★★");printf("\n 【】. 添加用户信息");printf("\n 【】. 读取所有用户信息");printf("\n 【】. 以姓名建立哈希表(再哈希法解决冲突) ");printf("\n 【】. 以电话号码建立哈希表(再哈希法解决冲突) ");printf("\n 【】. 查找并显示给定用户名的记录");printf("\n 【】. 查找并显示给定电话号码的记录");printf("\n 【】. 清屏");printf("\n 【】. 保存");printf("\n 【】. 退出程序");printf("\n 温馨提示:");printf("\n Ⅰ.进行操作前请先输出");printf("\n Ⅱ.进行操作前请先输出");printf("\n ★★★★★★★〓〓〓〓〓〓〓〓〓★★★★★★");printf("\n");printf("请输入一个任务选项>>>");printf("\n");int num;scanf("%d",&num);switch(num){case 1:getin(a);break;case 2:ShowInformation(a);break;case 3:CreateHash1(H,a); /* 以姓名建立哈希表*/break;case 4:CreateHash2(H,a); /* 以电话号码建立哈希表*/break;case 5:c=0;SearchHash1(H,c);break;case 6:c=0;SearchHash2(H,c);break;case 7:Cls(a);break;case 8:Save();break;case 9:return 0;break;default:printf("你输错了,请重新输入!");printf("\n");}}system("pause");return 0;}三、【实现描述(Implement)】(30%)(本部分应包括:抽象数据类型具体实现的函数原型说明、关键操作实现的伪码算法、函数设计、函数间的调用关系,关键的程序流程图等,给出关键算法的时间复杂度分析。
数据结构试验查找排序

实验七查找、排序的应用一、实验目的1、本实验可以使学生更进一步巩固各种查找和排序的基本知识。
2、学会比较各种排序与查找算法的优劣。
3、学会针对所给问题选用最适合的算法。
4、掌握利用常用的排序与选择算法的思想来解决一般问题的方法和技巧。
二、实验内容[问题描述]对学生的基本信息进行管理。
[基本要求]设计一个学生信息管理系统,学生对象至少要包含:学号、姓名、性别、成绩1、成绩2、总成绩等信息。
要求实现以下功能:1.总成绩要求自动计算;2.查询:分别给定学生学号、姓名、性别,能够查找到学生的基本信息(要求至少用两种查找算法实现);3.排序:分别按学生的学号、成绩1、成绩2、总成绩进行排序(要求至少用两种排序算法实现)。
[测试数据]由学生依据软件工程的测试技术自己确定。
三、实验前的准备工作1、掌握哈希表的定义,哈希函数的构造方法。
2、掌握一些常用的查找方法。
1、掌握几种常用的排序方法。
2、掌握直接排序方法。
四、实验报告要求1、实验报告要按照实验报告格式规范书写。
2、实验上要写出多批测试数据的运行结果。
3、结合运行结果,对程序进行分析。
一、需求分析设计一个学生信息管理系统,学生对象包含:学号、姓名、性别、班级、成绩1、成绩2、总成绩,要求实现以下功能:1.总成绩要求自动计算;2.查询:分别给定学生学号、姓名、性别,能够查找到学生的基本信息3.排序:分别按学生的学号、成绩1、成绩2、总成绩进行排序二、概要设计typedef struct{float num;//学生学号string name;//学生姓名string sex;//性别char className[20];//班级名称float mark1;//第1门成绩float mark2;//第2门成绩float sum;//第3门成绩}DataType;typedef struct //定义顺序表的结构{DataType r[ MAXSIZE +1 ]; //存储顺序表的向量int length; //顺序表的长度}SqList;int menu()菜单函数void CreatList(SqList &ST) //创建学生的相关信息void sort(SqList &ST) //排序void Query(SqList &ST) //查询信息void main()三、详细设计#include <iostream>#include<string>#include <iomanip>using namespace std;#define MAXSIZE 100typedef struct{float num;//学生学号string name;//学生姓名string sex;//性别char className[20];//班级名称float mark1;//第1门成绩float mark2;//第2门成绩float sum;//第3门成绩}DataType;typedef struct //定义顺序表的结构{DataType r[ MAXSIZE +1 ]; //存储顺序表的向量int length; //顺序表的长度}SqList;int menu(){int i;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 学生信息管理系统清单\n "<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 1.成绩的输入"<<endl;cout<<" 2.成绩查询"<<endl;cout<<" 3.成绩排序"<<endl;cout<<" 4.退出"<<endl;cout<<"请选择1-4:"<<endl;cin>>i;while(i<0||i>4){cout<<"系统提示: 您输入错误!"<<endl; //提示输入是否错误cout<<"请重新输入1-4: "<<endl;cin>>i;}return i;}void CreatList(SqList &ST) //创建学生的相关信息{cout<<"输入学生个数"<<endl;cin>>ST.length;cout<<" 学号姓名性别班级成绩1 成绩2 "<<endl;for(int i=0;i<ST.length;i++){cout<<"输入第"<<i+1<<"学生的信息"<<endl;cin>>ST.r[i].num>>ST.r[i].name>>ST.r[i].sex>>ST.r[i].className>>ST.r[i].mar k1>>ST.r[i].mark2;}cout<<"输入完毕"<<endl;}void output(SqList &ST)//输出{cout<<"学生的信息如下"<<endl;cout<<" 学号姓名性别班级成绩1 成绩2 总分"<<endl;for(int i=0;i<ST.length;i++)cout<<setw(6)<<ST.r[i].num<<setw(6)<<ST.r[i].name<<setw(6)<<ST.r[i].se x<<setw(6)<<ST.r[i].className<<setw(8)<<ST.r[i].mark1<<setw(8)<<ST.r[i].mark2 <<setw(8)<<ST.r[i].mark1+ST.r[i].mark2<<" "<<endl;}void Query(SqList &ST) //查询信息{cout<<endl;cout<<" (1)根据学号查询"<<endl;cout<<" (2)根据姓名查询"<<endl; cout<<" (3)根据性别查询"<<endl; cout<<" (4)退出"<<endl;int a,m,n,i,j;int low,high,mid;DataType LI; //使学号变为有序string name;string xb;cin>>m;switch(m){case 1: //折半查找for(i=1;i<ST.length;i++){for(j=i;j>=1;j--)if(ST.r[j].num<ST.r[j-1].num){LI=ST.r[j];ST.r[j]=ST.r[j-1];ST.r[j-1]=LI;}}a=0;cout<<"输入要查找的学号"<<endl;cin>>n;low=0;high=ST.length-1; // 置区间初值while (low<=high){mid=(low+high)/2;if(n==ST.r[mid].num){cout<<ST.r[mid].num<<" "<<ST.r[mid].name<<" "<<ST.r[mid].sex<<" "<<ST.r[mid].className<<" "<<ST.r[mid].mark1<<" "<<ST.r[mid].mark2<<" "<<(ST.r[mid].mark1+ST.r[mid].mark2)<<endl;a=1;break;}else if(n<ST.r[mid].num)high=mid-1; // 继续在前半区间进行查找elselow=mid+1; // 继续在后半区间进行查找}if(!a){cout<<"所查信息不存在!"<<endl;cout<<"请重新输入"<<endl;}break;case 2: //顺序查找{a=0;cout<<"输入要查找的姓名"<<endl;cin>>name;for(i=0;i<ST.length;i++){if(name==ST.r[i].name){cout<<ST.r[i].num<<" "<<ST.r[i].name<<" "<<ST.r[i].sex<<" "<<ST.r[i].className<<" "<<ST.r[i].mark1<<" "<<ST.r[i].mark2<<" "<<ST.r[i].mark1+ST.r[i].mark2<<endl;a=1;}}if(!a){cout<<"所查信息不存在!"<<endl;cout<<"请重新输入"<<endl;}break;}case 3: //顺序查找{a=0;cout<<"输入要查找性别"<<endl;cin>>xb;for(i=0;i<ST.length;i++){if(xb==ST.r[i].sex){cout<<ST.r[i].num<<" "<<ST.r[i].name<<" "<<ST.r[i].sex<<" "<<ST.r[i].className<<" "<<ST.r[i].mark1<<" "<<ST.r[i].mark2<<" "<<ST.r[i].mark1+ST.r[i].mark2<<endl;a=1;}}if(!a){cout<<"所查信息不存在!"<<endl;cout<<"请重新输入"<<endl;}break;}case 4:menu();break;}}void sort(SqList &ST) //排序{int n,i,j;DataType LI; //定义存储学号向量cout<<endl;cout<<" (1)根据学号排序"<<endl;cout<<" (2)根据成绩1排序"<<endl;cout<<" (3)根据成绩2排序"<<endl;cout<<" (4)根据总成绩排序"<<endl;cout<<" (5)退出"<<endl;cin>>n;switch(n){case 1: //按学号排序,使用插入排序for(i=1;i<ST.length;i++)for(j=i;j>=1;j--)if(ST.r[j].num<ST.r[j-1].num){LI=ST.r[j];ST.r[j]=ST.r[j-1];ST.r[j-1]=LI;}output(ST);cout<<"排序完毕"<<endl;break;case 2: //按成绩1排序,用选择排序for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].mark1>ST.r[j].mark1){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;}}}output(ST);cout<<"排序完毕"<<endl;break;case 3: // 根据成绩2排序,使用选择法排for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].mark2>ST.r[j].mark2){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;}}output(ST);cout<<"排序完毕"<<endl;break;case 4: //根据总成绩排序,使用选择法排序for(i=0; i<ST.length;i++){for (j=i+1;j<ST.length;j++){if(ST.r[i].sum>ST.r[j].sum){LI=ST.r[j];ST.r[j]=ST.r[i];ST.r[i]=LI;}}}output(ST);cout<<"排序完毕"<<endl;break;case 5: //退出menu();break;}}}#include"查找排序.h"void main(){SqList ST;while(1){switch(menu()){case 1:cout<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 1.成绩的输入"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;CreatList(ST);break;case 2:cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 2.成绩的查询"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;Query(ST);break;case 3:cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 3.成绩的排序"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;sort(ST);break;case 4:cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;cout<<" 4.退出"<<endl;cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;exit(0);break;}}}四、运行结果图表1图表2图表3图表 4图表 5图表 6图表7图表8五、心得体会整个程序前前后后整整用了一个星期,每天只要有空闲时间就在翻书本,画流程图,写代码,反反复复一点一点。
数据结构实验七-二分排序

1
void main() {
rec A; int j,n,i; printf("\n\n 输入初始数据(每个数据一空格隔开,-1结束):"); n=0; scanf("%d", &j); while(j!=-1) {
n++; A[n]=j; scanf("%d",&j); } printf("插入排序\n\n排序前\n\n"); for (i=1;i<=n;i++) printf("%d ", A[i]); InsertSort1(A,n); printf("\n\n排序后\n\n"); for (i=1;i<=n;i++) printf("%d ", A[i]); }
2
数据结构实验报告七
班级:
姓名: 吴前斌
学号:
课程名称
数据结构
实验项目 排序
实验项目类型 验演综设 证示合计
指导掌握二分排序的基本概念,掌握二分排序的基本思想和算法实现。
二、实验内容 设计一个算法用二分查找实现插入排序的“寻找插入位置”操作。
三、实验要求 二分查找:在有序表中进行,先确定表的中点位置,再通过比较确定下一步查找哪个半区。
四、实验过程及结果:
# include "stdio.h" # define Max 20 typedef int elemtype; typedef elemtype rec[Max];
void InsertSort1(rec A,int n) {
int i,j,low,high,mid,now; for(i=2; i<=n; i++) {
数据结构(Java语言描述)第七章 查找

第七章 查找
目录
1 查找
2 静态查找表
第七章 查找
动态查找表 哈希表 小结
总体要求
•掌握顺序查找、折半查找的实现方法; •掌握动态查找表(包括:二叉排序树、二叉平衡树 、B-树)的构造和查找方法; •掌握哈希表、哈希函数冲突的基本概念和解决冲突 的方法。
7.1基本概念
1、数据项 数据项是具有独立含义的标识单位,是数据不可分 割的最小单位。 2、数据元素 数据元素数是据由项若(名干) 数据项构成的数据单位,是在某
}
性能分析:i 0 1 2 3 4
5 13 19 21 37
Ci 3 4 2 3 4
查找成功:
比较次数 = 路径上的结点数
比较次数 = 结点 4 的层数
比较次数
2
56 7 56 64 75 1 34
判定树
5
8 9 10 80 88 92 2 34
查找37 8
树的深度
0
3
6
9
≤=
log2n +1
1
4
}
【算法7-1】初始化顺序表 public SeqTable(T[] data,int n){
elem=new ArrayList<ElemType<T>>(); ElemType<T> e; for(int i=0;i<n;i++){
e=new ElemType<T>(data[i]); elem.add(i, e); } length=n; }
前者叫作最大查找长度(Maximun Search Length),即 MSL。后者叫作平均查找长度(Average Search Length) ,即ASL。
数据结构第7章查找

于等于根结点的值; (3)其左右子树本身又各是一棵二叉排序树
2021年7月21日
练习
下列图形中,哪个不是二叉排序树 ?
2021年7月21日
练习
中序遍历二叉排序 树后的结果有什么 规律?
45 12
3
37
24 3,12,24,37,45,53,61,78,90,100
• 重复上述操作,直至low>high时,查找失败
2021年7月21日
折半查找(递归算法)
int Search_Bin (SSTable ST, keyType key, int low, int high) { if(low>high) return 0; //查找不到时返回0 mid=(low+high)/2; if(key与ST.elem[mid].key) return mid; else if(key小于ST.elem[mid].key)
……..//递归 else……. //递归 }
2021年7月21日
折半查找的性能分析-判定树
1 2 3 4 5 6 7 8 9 10 11 5 13 19 21 37 56 64 75 80 88 92
6 < => 3
1
4
7
1 2 9
10 内结点
-1 2 3-4 5 6-7 8 9-10 11 h
1-2 2-3
4-5 5-6
7-8 8-9 10-11 11-
外结点
查找成功时比较次数:为该结点在判定树上的层次数,不超过树 的深度 d = log2 n + 1
查找不成功的过程就是走了一条从根结点到外部结点的路径d或 d-1。
数据结构实验七 查找

数据结构实验七查找数据结构实验七查找第一章实验目的本实验旨在掌握查找算法的实现原理及应用,深入理解各种查找算法的性能特点。
第二章实验内容1.实现顺序查找算法。
2.实现二分查找算法。
3.实现哈希查找算法。
4.实现二叉排序树查找算法。
5.实现平衡二叉树查找算法。
6.实现B+树查找算法。
7.使用不同的查找算法对随机的数据集进行查找,并比较它们的查找效率。
第三章实验步骤及详解1.顺序查找算法实现1.1.定义一个函数来实现顺序查找算法。
1.2.从待查找的数组的第一个元素开始遍历,逐个与目标元素进行比较。
1.3.如果找到目标元素,返回元素所在的位置索引。
1.4.如果遍历完整个数组仍未找到目标元素,返回-1表示未找到。
2.二分查找算法实现2.1.定义一个函数来实现二分查找算法。
2.2.对有序数组进行查找,首先确定查找范围的左右边界。
2.3.取查找范围的中间元素与目标元素进行比较。
2.4.如果相等,返回中间元素所在的位置索引。
2.5.如果目标元素小于中间元素,说明目标元素在左半部分,更新右边界。
2.6.如果目标元素大于中间元素,说明目标元素在右半部分,更新左边界。
2.7.继续迭代直到找到目标元素或者查找范围为空。
3.哈希查找算法实现3.1.定义一个哈希表数据结构。
3.2.将待查找的元素通过哈希函数转换为哈希值。
3.3.使用哈希值作为索引在哈希表中查找元素。
3.4.如果找到目标元素,返回元素所在的位置索引。
3.5.如果哈希表中对应的位置为空或者不匹配目标元素,表示未找到。
4.二叉排序树查找算法实现4.1.定义一个二叉树数据结构。
4.2.将待查找的元素按照大小依次插入二叉排序树中。
4.3.如果待查找的元素与当前节点相等,返回当前节点。
4.4.如果待查找的元素小于当前节点,继续在当前节点的左子树中查找。
4.5.如果待查找的元素大于当前节点,继续在当前节点的右子树中查找。
4.6.如果遍历完整个二叉排序树仍未找到目标元素,返回空指针表示未找到。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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);}}。