数据结构实验——查找算法的实现
数据结构与算法实验报告
《数据结构与算法》综合实验报告系别：专业：学生姓名：指导教师：2011年 11月 25日实验目的掌握线性表的建立、插入、删除算法；掌握查找算法；掌握排序算法；实验要求使用C语言（环境任意）开发程序，能够对用户输入的任意一组数据，建立一个线性表，可以输出此线性表。
并且能够对此线性表进行插入、删除、查找、排序等操作。
程序流程建表如下：定义一个整型的数据类型data和next指针：定义头指针和当前结点指针，申请连续空间将单个字节大小复制给头指针，把头指针赋值给当前节点指针：若输入的数是0，则若输入不为0，把输入的数赋值给已申请的新结点，把新结点赋给当前节点的next域，再把新结点赋值给当前结点，以此方法重复执行得到如下链表：输出函数：把头指针赋值给当前结点指针，当当前节点的next域不为空时输出当前节点所指向的数据，把当前结点的next域赋值给当前节点，否则输出链表为空对此线性表进行插入、删除、查询、排序操作把已申请的结点数据域指向所输入的数再把插入w结点赋值头结点，是插入的位置，如果w=0则插入结点的next域赋值给头结点否则如果w>表长，则输出超出范围代码及运行结果（主要语句要求有注释）#include"stdafx.h"#include<stdio.h>#include<malloc.h>#define NULL 0typedef struct linknode{int data;struct linknode *next;}node;node *head;node *creat(){node *currnode,*newnode;int x;head=(node*)malloc(sizeof(node));currnode=head;do{scanf("%d",&x);newnode=(node*)malloc(sizeof(node));newnode->data=x;currnode->next=newnode;currnode=newnode;}while(x!=NULL);head=head->next;currnode->next=NULL;return head;};int length(){node *currnode;int i=0;currnode=head;while(currnode->data!=NULL){currnode=currnode->next;i++;};return i;};void print(){node *currnode;currnode=head;printf("链表如下....linklist");while(currnode->data!=NULL){printf("%d-->",currnode->data);currnode=currnode->next;};printf("NULL\n");printf("链表长度为........linklist length%d\n",length());};void delete1(){int x;node *delnode,*currnode;printf("输入要删除的数据......input delete data：");scanf("%d",&x);if(head->data==NULL) printf("此链表为空无法删除.....this linklist empty！\n"); if(head->data==x){delnode=head;head=head->next;free(delnode);if(head==NULL) printf("此链表为空.......this linklist enpty！");}else{currnode=head;delnode=currnode->next;while(delnode->data!=x&&delnode!=NULL){currnode=currnode->next;delnode=currnode->next;};if(delnode==NULL)printf("无此数据......no this data！\n");else{currnode->next=delnode->next;free(delnode);};};};void find(){node *currnode;int count=1,x;currnode=head;printf("输入要查找的数据.......input search data:");scanf("%d",&x);while(currnode->data!=NULL&&currnode->data!=x) {currnode=currnode->next;count++;};if(currnode->data!=NULL){printf("\n%d为第........is no.",currnode->data);printf("%d个数据........data。
数据结构——查找,顺序查找,折半查找
实验五查找的应用一、实验目的：1、掌握各种查找方法及适用场合，并能在解决实际问题时灵活应用。
2、增强上机编程调试能力。
二、问题描述1.分别利用顺序查找和折半查找方法完成查找。
有序表（3,4,5,7,24,30,42,54,63,72,87,95）输入示例：请输入查找元素：52输出示例：顺序查找：第一次比较元素95第二次比较元素87 ……..查找成功，i=**/查找失败折半查找：第一次比较元素30第二次比较元素63 …..2.利用序列（12,7,17,11,16,2,13,9,21,4）建立二叉排序树，并完成指定元素的查询。
输入输出示例同题1的要求。
三、数据结构设计（选用的数据逻辑结构和存储结构实现形式说明）（1）逻辑结构设计顺序查找和折半查找采用线性表的结构，二叉排序树的查找则是建立一棵二叉树，采用的非线性逻辑结构。
（2）存储结构设计采用顺序存储的结构，开辟一块空间用于存放元素。
（3）存储结构形式说明分别建立查找关键字，顺序表数据和二叉树数据的结构体进行存储数据四、算法设计（1）算法列表（说明各个函数的名称，作用，完成什么操作）序号 名称 函数表示符 操作说明1 顺序查找 Search_Seq 在顺序表中顺序查找关键字的数据元素2 折半查找 Search_Bin 在顺序表中折半查找关键字的数据元素3 初始化 Init 对顺序表进行初始化，并输入元素4 树初始化 CreateBST 创建一棵二叉排序树5 插入 InsertBST 将输入元素插入到二叉排序树中6 查找 SearchBST在根指针所指二叉排序树中递归查找关键字数据元素 （2）各函数间调用关系（画出函数之间调用关系）typedef struct { ElemType *R; int length;}SSTable;typedef struct BSTNode{Elem data; //结点数据域 BSTNode *lchild,*rchild; //左右孩子指针}BSTNode,*BSTree; typedef struct Elem{ int key; }Elem;typedef struct {int key;//关键字域}ElemType;（3）算法描述int Search_Seq(SSTable ST, int key){//在顺序表ST中顺序查找其关键字等于key的数据元素。
数据结构中的查找算法总结
数据结构中的查找算法总结静态查找是数据集合稳定不需要添加删除元素的查找包括：1. 顺序查找2. 折半查找3. Fibonacci4. 分块查找静态查找可以⽤线性表结构组织数据，这样可以使⽤顺序查找算法，再对关键字进⾏排序就可以使⽤折半查找或斐波那契查找等算法提⾼查找效率，平均查找长度：折半查找最⼩，分块次之，顺序查找最⼤。
顺序查找对有序⽆序表均适⽤，折半查找适⽤于有序表，分块查找要求表中元素是块与块之间的记录按关键字有序动态查找是数据集合需要添加删除元素的查找包括： 1. ⼆叉排序树 2. 平衡⼆叉树 3. 散列表 顺序查找适合于存储结构为顺序存储或链接存储的线性表。
顺序查找属于⽆序查找算法。
从数据结构线形表的⼀端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相⽐较，若相等则表⽰查找成功 查找成功时的平均查找长度为： ASL = 1/n(1+2+3+…+n) = (n+1)/2 ; 顺序查找的时间复杂度为O(n)。
元素必须是有序的，如果是⽆序的则要先进⾏排序操作。
⼆分查找即折半查找，属于有序查找算法。
⽤给定值value与中间结点mid的关键字⽐较，若相等则查找成功；若不相等，再根据value 与该中间结点关键字的⽐较结果确定下⼀步查找的⼦表 将数组的查找过程绘制成⼀棵⼆叉树排序树，如果查找的关键字不是中间记录的话，折半查找等于是把静态有序查找表分成了两棵⼦树，即查找结果只需要找其中的⼀半数据记录即可，等于⼯作量少了⼀半，然后继续折半查找，效率⾼。
根据⼆叉树的性质，具有n个结点的完全⼆叉树的深度为[log2n]+1。
尽管折半查找判定⼆叉树并不是完全⼆叉树，但同样相同的推导可以得出，最坏情况是查找到关键字或查找失败的次数为[log2n]+1，最好的情况是1次。
时间复杂度为O(log2n)； 折半计算mid的公式 mid = (low+high)/2;if(a[mid]==value)return mid;if(a[mid]>value)high = mid-1;if(a[mid]<value)low = mid+1; 折半查找判定数中的结点都是查找成功的情况，将每个结点的空指针指向⼀个实际上不存在的结点——外结点，所有外界点都是查找不成功的情况，如图所⽰。
算法与及数据结构实验报告
算法与及数据结构实验报告算法与数据结构实验报告一、实验目的本次算法与数据结构实验的主要目的是通过实际操作和编程实现，深入理解和掌握常见算法和数据结构的基本原理、特性和应用，提高我们解决实际问题的能力和编程技巧。
二、实验环境本次实验使用的编程语言为 Python，开发环境为 PyCharm。
同时，为了进行算法性能的分析和比较，使用了 Python 的 time 模块来计算程序的运行时间。
三、实验内容1、线性表的实现与操作顺序表的实现：使用数组来实现顺序表，并实现了插入、删除、查找等基本操作。
链表的实现：通过创建节点类来实现链表，包括单向链表和双向链表，并完成了相应的操作。
2、栈和队列的应用栈的实现与应用：用数组或链表实现栈结构，解决了表达式求值、括号匹配等问题。
队列的实现与应用：实现了顺序队列和循环队列，用于模拟排队系统等场景。
3、树结构的探索二叉树的创建与遍历：实现了二叉树的先序、中序和后序遍历算法，并对其时间复杂度进行了分析。
二叉搜索树的操作：构建二叉搜索树，实现了插入、删除、查找等操作。
4、图的表示与遍历邻接矩阵和邻接表表示图：分别用邻接矩阵和邻接表来存储图的结构，并对两种表示方法的优缺点进行了比较。
图的深度优先遍历和广度优先遍历：实现了两种遍历算法，并应用于解决路径查找等问题。
5、排序算法的比较插入排序、冒泡排序、选择排序：实现了这三种简单排序算法，并对不同规模的数据进行排序，比较它们的性能。
快速排序、归并排序：深入理解并实现了这两种高效的排序算法，通过实验分析其在不同情况下的表现。
6、查找算法的实践顺序查找、二分查找：实现了这两种基本的查找算法，并比较它们在有序和无序数据中的查找效率。
四、实验步骤及结果分析1、线性表的实现与操作顺序表：在实现顺序表的插入操作时，如果插入位置在表的末尾或中间，需要移动后续元素以腾出空间。
删除操作同理，需要移动被删除元素后面的元素。
在查找操作中，通过遍历数组即可完成。
数据结构的查找算法
数据结构的查找算法在计算机科学中，数据结构是用于组织和存储数据的一种方式。
查找算法是数据结构中的重要部分，它用于在数据集合中搜索特定元素或信息。
本文将介绍几种常见的数据结构查找算法，包括线性查找、二分查找、哈希查找以及树结构的查找算法。
1. 线性查找线性查找是一种简单直观的查找方法，适用于无序的数据集合。
其基本思想是从数据集合的第一个元素开始逐个比较，直到找到目标元素或者遍历完整个数据集合。
由于线性查找需要遍历所有元素，所以时间复杂度为O(n)，其中n为数据集合的大小。
2. 二分查找二分查找是一种高效的查找算法，但它要求数据集合中的元素必须有序。
具体实现方式是将数据集合分为两半，然后与目标元素进行比较，不断缩小查找范围，直到找到目标元素或者确定目标元素不存在。
由于每次都将查找范围减小一半，所以时间复杂度为O(log n)，其中n为数据集合的大小。
3. 哈希查找哈希查找利用哈希函数将目标元素映射到哈希表中的特定位置，从而快速定位目标元素。
哈希表是一种以键-值对形式存储数据的数据结构，可以快速插入和删除元素，因此在查找时具有良好的性能。
哈希查找的时间复杂度为O(1)，但在处理哈希冲突时可能会影响性能。
4. 树结构的查找算法树是一种常见的数据结构，其查找算法主要包括二叉搜索树、平衡二叉搜索树以及B树和B+树。
二叉搜索树是一种有序的二叉树，左子树的所有节点值都小于根节点，右子树的所有节点值都大于根节点。
通过比较目标元素与节点的值，可以快速定位目标元素。
平衡二叉搜索树是为了解决二叉搜索树在某些情况下可能出现的退化情况，通过旋转操作保持树的平衡性。
B树和B+树是一种多路搜索树，它们可以减少磁盘I/O操作，适用于大规模数据的查找。
综上所述，数据结构的查找算法是计算机科学中的重要内容。
不同的查找算法适用于不同的场景，选择合适的算法可以提高查找效率。
在实际应用中，需要根据数据集合的特点及查找需求来选择合适的算法。
数据结构课程设计两种常用查找算法的比较与实现
数据结构课程设计--两种常用查找算法的比较与实现两种常用查找算法的比较与实现摘要：本次课程设计主要研究几种常用查找算法的比较与实现，查找的算法有很多种：静态查找表的顺序表、有序表、索引顺序表等查找结构；动态查找表的二叉排序树、哈希查找等查找结构。
本次的课程设计主要研究两种常见的查找算法：顺序查找和折半查找，分析比较它们的时间复杂度，并且在此基础上用C语言对它们进行算法编程、调试和运行。
关键词：C语言；顺序查找；折半查找;时间复杂度。
２1引言“数据结构”在计算机科学中是一门综合性的专业基础课，“数据结构”的研究不仅涉及到计算机硬件的研究范围，而且和计算机软件的研究有着密切的关系无论是编译程序还是操作系统，都涉及到数据元素在存储器中的分配问题。
在研究信息检索时也必须考虑如何组织数据，一遍查找和存取数据元素更为方便。
因此，可以认为“数据结构”是介于数学、计算机硬件和计算机软件三者之间的一门核心课程。
课程设计是我们专业课程知识综合应用的实践训练，是实践性教学的一个重要环节。
而数据结构的课程设计，更要求学生在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面，加深对课程基本内容的理解。
同时，在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。
在日常生活中，人们几乎每天都要进行“查找”工作。
例如，在电话号码薄中查阅“某单位”或“某人”的电话号码；在字典中查阅“某个词”的读音和含义等等。
而同样地，在各种系统软件和应用软件中，也存在“查找”：如编译程序中符号表、信息处理表中相关信息的查找。
所以，“查找”就是在一个含有众多的数据元素（或记录）的查找表中找出某个“特定的”数据元素（或记录）【1】。
在计算机中进行查找的方法也会随数据结构不同而不同。
在此，引入“查找表”的概念：同类数据元素构成的集合。
所以，这次的课程设计就可以从静态查找表的几种典型的算法来实现对数据元素的查找的算法和操作的实现和比较。
常用查找算法及其实践应用
常用查找算法及其实践应用查找算法是计算机科学中的一类基本算法，用于在一组数据中快速查找目标值。
本文将介绍常用的查找算法及其实践应用，并讨论它们的优缺点。
一、线性查找算法线性查找算法，也称作顺序查找算法，是最简单直接的查找算法之一。
它通过逐个比较数据元素，直到找到目标值或搜索整个数据集。
实践应用：线性查找算法适用于数据量较小且无序的情况。
例如，在一个未排序的数组中查找一个特定的值。
二、二分查找算法二分查找算法，也称作折半查找算法，是一种高效的查找算法。
它将目标值与数据集的中间值进行比较，根据比较结果将搜索范围缩小一半，以此类推，直到找到目标值或搜索范围为空。
实践应用：二分查找算法适用于已排序的数据集。
比如，在一个有序数组中查找一个特定的值。
三、哈希查找算法哈希查找算法通过哈希函数将数据映射到一个固定的位置，然后在该位置进行查找。
它的平均查找时间复杂度为O(1)，具有高效的查找速度。
实践应用：哈希查找算法适用于查找大规模数据集中的特定值。
它常被用于数据库索引、缓存系统等。
四、二叉查找树算法二叉查找树算法，也称作二叉搜索树算法，是一种基于二叉树的查找算法。
它具有以下特点：左子树的所有节点小于根节点，右子树的所有节点大于根节点。
通过比较目标值与根节点的大小关系，可以快速缩小搜索范围。
实践应用：二叉查找树算法适用于频繁插入和删除操作的场景。
它常被用于实现字典、关联数组等数据结构。
五、平衡查找树算法平衡查找树算法，如红黑树、AVL树等，是对二叉查找树的改进。
它通过调整节点的颜色和旋转操作来保持树的平衡，以确保查找效率的稳定性。
实践应用：平衡查找树算法适用于高效地处理大规模数据集的查找、插入和删除操作。
它常被用于数据库索引、编译器等领域。
六、后缀树算法后缀树算法是一种用于字符串查找的数据结构。
它将目标字符串的所有后缀都表示为树的节点，通过遍历树来查找目标字符串的子串。
实践应用：后缀树算法适用于文本搜索、模式匹配等领域。
数据结构查找实验报告
数据结构查找实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法，包括顺序查找、二分查找、哈希查找等，并通过实际编程实现和性能比较，分析它们在不同数据规模和分布情况下的效率和适用场景。
二、实验环境本次实验使用的编程语言为 Python 38，开发环境为 PyCharm。
实验中所使用的数据集生成工具为 numpy 库。
三、实验原理1、顺序查找顺序查找是一种最简单的查找算法，它从数据结构的开头依次逐个比较元素，直到找到目标元素或遍历完整个数据结构。
其平均时间复杂度为 O(n)。
2、二分查找二分查找要求数据结构是有序的。
通过不断将查找区间缩小为原来的一半，直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)。
3、哈希查找哈希查找通过将元素映射到一个特定的哈希表中，利用哈希函数计算元素的存储位置，从而实现快速查找。
理想情况下，其平均时间复杂度为 O(1)，但在存在哈希冲突时，性能可能会下降。
四、实验步骤1、数据集生成使用 numpy 库生成不同规模和分布的数据集，包括有序数据集、无序数据集和具有一定重复元素的数据集。
2、顺序查找实现编写顺序查找算法的函数，接受数据集和目标元素作为参数，返回查找结果（是否找到及查找次数）。
3、二分查找实现实现二分查找算法的函数，同样接受数据集和目标元素作为参数，并返回查找结果。
4、哈希查找实现构建哈希表并实现哈希查找函数，处理哈希冲突的情况。
5、性能比较对不同规模和类型的数据集，分别使用三种查找算法进行查找操作，并记录每种算法的查找时间和查找次数。
五、实验结果与分析1、顺序查找在无序数据集中，顺序查找的性能表现较为稳定，查找时间随着数据规模的增大线性增长。
但在有序数据集中，其性能没有优势。
2、二分查找二分查找在有序数据集中表现出色，查找时间随着数据规模的增大增长缓慢，体现了对数级别的时间复杂度优势。
然而，在无序数据集中无法使用。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验五查找算法实现1、实验目的熟练掌握顺序查找、折半查找及二叉排序树、平衡二叉树上的查找、插入和删除的方法，比较它们的平均查找长度。
2、问题描述查找表是数据处理的重要操作，试建立有100个结点的二叉排序树进行查找，然后用原数据建立AVL树，并比较两者的平均查找长度。
3、基本要求（1）以链表作为存储结构，实现二叉排序树的建立、查找和删除。
（2）根据给定的数据建立平衡二叉树。
4、测试数据随即生成5、源程序#include<>#include<>#include<>#define EQ(a,b) ((a)==(b))#define LT(a,b) ((a)<(b))#define LQ(a,b) ((a)>(b))typedef int Keytype;typedef struct{ Keytype key; //关键字域}ElemType;typedef struct BSTnode{ ElemType data;int bf;struct BSTnode *lchild,*rchild;}BSTnode,*BSTree;void InitBSTree(BSTree &T){T=NULL;}void R_Rotate(BSTree &p){BSTnode *lc;lc=p->lchild;p->lchild=lc->rchild;lc->rchild=p;p=lc;}void L_Rotate(BSTree &p){BSTnode *rc;rc=p->rchild;p->rchild=rc->lchild;rc->lchild=p;p=rc;}void Leftbalance(BSTree &T) {BSTnode *lc,*rd;lc=T->lchild;switch(lc->bf){case +1:T->bf=lc->bf=0; R_Rotate(T);break;case -1:rd=lc->rchild; switch(rd->bf){ case 1:T->bf=-1;lc->bf=0;break;case 0:T->bf=lc->bf=0;break;case -1:T->bf=0;lc->bf=1;break;}rd->bf=0;L_Rotate(T->lchild);R_Rotate(T);}}void Rbalance(BSTree &T) {BSTnode *lc,*ld;lc=T->rchild;switch(lc->bf){ case 1:ld=lc->lchild;switch(ld->bf){ case 1:T->bf=0;lc->bf=-1;break;case 0:T->bf=lc->bf=0;break;case -1:T->bf=1;lc->bf=0;break;}ld->bf=0;R_Rotate(T->rchild);L_Rotate(T);case -1:T->bf=lc->bf=0;L_Rotate(T);break;}}int InsertAVL(BSTree &T,ElemType e,bool &taller) { if(!T){ T=(BSTree)malloc(sizeof(BSTnode));T->data=e;T->lchild=T->rchild=NULL;T->bf=0;taller=true;}else{ if(EQ,T->){ taller=false;cout<<"结点 "<<<<" 不存在。
"<<endl;return 0;}if(LT,T->){ if(!InsertAVL(T->lchild,e,taller)){ return 0;}if(taller)switch(T->bf){ case 1:Leftbalance(T);taller=false;break;case 0:T->bf=+1;taller=true;break;case -1:T->bf=0;taller=false;break;}}else{ if(!InsertAVL(T->rchild,e,taller)){ return 0;}if(taller)switch(T->bf){ case 1:T->bf=0;taller=false;break;case 0:T->bf=-1;taller=true;break;case -1:Rbalance(T);taller=false;break;}}}return 1;}bool SearchBST(BSTree T,ElemType key,BSTree f,BSTree &p) { if(!T){ p=f;cout<<"结点不存在。
"<<endl;return false;}else if( EQ,T-> ){ p=T;cout<<"查找成功，存在结点";cout<<p-><<endl;return true;}else if(LT,T->)return SearchBST(T->lchild,key,T,p);return SearchBST(T->rchild,key,T,p);}void Leftbalance_div(BSTree &p,int &shorter){ BSTree p1,p2;if(p->bf==+1) //p结点的左子树高，删除结点后p的bf减1,树变矮{ p->bf=0;shorter=1;}else if(p->bf==0)//p结点左、右子树等高，删除结点后p的bf减1,树高不变{ p->bf=-1;shorter=0;}else{ p1=p->rchild;//p1指向p的右子树if(p1->bf==0)//p1结点左、右子树等高,删除结点后p的bf为-2,进行左旋处理，树高不变{ L_Rotate(p);p1->bf=1;p->bf=-1;shorter=0;}else if(p1->bf==-1)//p1的右子树高，左旋处理后，树变矮{ L_Rotate(p);p1->bf=p->bf=0;shorter=1;}else{ p2=p1->lchild;p1->lchild=p2->rchild;p2->rchild=p1;p->rchild=p2->lchild;p2->lchild=p;if(p2->bf==0){ p->bf=0;p1->bf=0;}else if(p2->bf==-1){ p->bf=+1;p1->bf=0;}else{ p->bf=0;p1->bf=-1;p2->bf=0;p=p2;shorter=1;}}}void Rbalance_div(BSTree &p,int &shorter) { BSTree p1,p2;if(p->bf==-1){ p->bf=0;shorter=1;}else if(p->bf==0){ p->bf=+1;shorter=0;}else{ p1=p->lchild;if(p1->bf==0){ R_Rotate(p);p1->bf=-1;p->bf=+1;shorter=0;}else if(p1->bf==+1){ R_Rotate(p);p1->bf=p->bf=0;shorter=1;}else{ p2=p1->rchild;p1->rchild=p2->lchild;p2->lchild=p1;p->lchild=p2->rchild;p2->rchild=p;if(p2->bf==0){ p->bf=0;p1->bf=0;}else if(p2->bf==1){ p->bf=-1;p1->bf=0;}else{ p->bf=0;p1->bf=1;}p2->bf=0;p=p2;shorter=1;}}}void Delete(BSTree q,BSTree &r,int &shorter){ if(r->rchild==NULL){ q->data=r->data;q=r;r=r->lchild;free(q);shorter=1;}else{ Delete(q,r->rchild,shorter);if(shorter==1)Rbalance_div(r,shorter);}}ElemType DeleteAVL(BSTree &p,ElemType key,int &shorter) { ElemType k,a,b;=1;=0;BSTree q;if(p==NULL){ cout<<"结点不存在。
"<<endl;return b;}else if(LT,p-> )//在p的左子树中进行删除{ k=DeleteAVL(p->lchild,key,shorter);if(shorter==1)Leftbalance_div(p,shorter);return k;}else if(LQ,p-> )//在p的右子树中进行删除{ k=DeleteAVL(p->rchild,key,shorter);Rbalance_div(p,shorter);return k;}else{q=p;if(p->rchild==NULL) //右子树空则只需重接它的左子树{ p=p->lchild;free(q);shorter=1;}else if(p->lchild==NULL)//左子树空则只需重接它的右子树 { p=p->rchild;free(q);shorter=1;}else{ Delete(q,q->lchild,shorter);if(shorter==1)Leftbalance_div(p,shorter);p=q;}return a;}}void Print_BSTTree(BSTree T,int i){ if(T){ if(T->rchild)Print_BSTTree(T->rchild,i+1);for(int j=1;j<=i;j++)cout<<" ";cout<<T-><<endl;if(T->lchild)Print_BSTTree(T->lchild,i+1);}}int main(){ BSTree T;ElemType e;InitBSTree(T);bool tall=false;bool choice=true;char y;{ cout<<"输入要插入结点(数字):";cin>>;InsertAVL(T,e,tall);Print_BSTTree(T,0);cout<<"是否继续，是选y，否选n:"; cin>>y;if(y=='Y'||y=='y')choice=true;else choice=false;}BSTree f,p;choice=true;while(choice){ cout<<"输入要查找的结点:";cin>>;SearchBST( T,e,f,p);cout<<"是否继续，是选y，否选n："; cin>>y;if(y=='Y'||y=='y')choice=true;else choice=false;}int shorter;choice=true;while(choice){ cout<<"输入要删除的结点:";cin>>;DeleteAVL(T,e,shorter);Print_BSTTree(T,0);cout<<"是否继续，是选y，否选n："; cin>>y;if(y=='Y'||y=='y')choice=true;else choice=false;}return 0;}。