二叉排序树的基本操作的实现
数据结构平衡二叉树的操作演示
平衡二叉树操作的演示1.需求分析本程序是利用平衡二叉树，实现动态查找表的基本功能：创建表，查找、插入、删除。
具体功能：（1）初始，平衡二叉树为空树，操作界面给出创建、查找、插入、删除、合并、分裂六种操作供选择。
每种操作均提示输入关键字。
每次插入或删除一个结点后，更新平衡二叉树的显示。
（2）平衡二叉树的显示采用凹入表现形式。
（3）合并两棵平衡二叉树。
（4）把一棵二叉树分裂为两棵平衡二叉树，使得在一棵树中的所有关键字都小于或等于x，另一棵树中的任一关键字都大于x。
如下图：2．概要设计平衡二叉树是在构造二叉排序树的过程中，每当插入一个新结点时，首先检查是否因插入新结点而破坏了二叉排序树的平衡性，若是则找出其中的最小不平衡子树，在保持二叉排序树特性的前提下，调整最小不平衡子树中各结点之间的链接关系，进行相应的旋转，使之成为新的平衡子树。
具体步骤：（1）每当插入一个新结点，从该结点开始向上计算各结点的平衡因子，即计算该结点的祖先结点的平衡因子，若该结点的祖先结点的平衡因子的绝对值不超过1，则平衡二叉树没有失去平衡，继续插入结点；（2）若插入结点的某祖先结点的平衡因子的绝对值大于1，则找出其中最小不平衡子树的根结点；（3）判断新插入的结点与最小不平衡子树的根结点个关系，确定是那种类型的调整；（4）如果是LL型或RR型，只需应用扁担原理旋转一次，在旋转过程中，如果出现冲突，应用旋转优先原则调整冲突；如果是LR型或RL型，则需应用扁担原理旋转两次，第一次最小不平衡子树的根结点先不动，调整插入结点所在子树，第二次再调整最小不平衡子树，在旋转过程中，如果出现冲突，应用旋转优先原则调整冲突；（5）计算调整后的平衡二叉树中各结点的平衡因子，检验是否因为旋转而破坏其他结点的平衡因子，以及调整后平衡二叉树中是否存在平衡因子大于1的结点。
流程图3.详细设计二叉树类型定义：typedef int Status;typedef int ElemType;typedef struct BSTNode{ElemType data;int bf;struct BSTNode *lchild ,*rchild;} BSTNode,* BSTree;Status SearchBST(BSTree T,ElemType e)//查找void R_Rotate(BSTree &p)//右旋void L_Rotate(BSTree &p)//左旋void LeftBalance(BSTree &T)//插入平衡调整void RightBalance(BSTree &T)//插入平衡调整Status InsertAVL(BSTree &T,ElemType e,int &taller)//插入void DELeftBalance(BSTree &T)//删除平衡调整void DERightBalance(BSTree &T)//删除平衡调整Status Delete(BSTree &T,int &shorter)//删除操作Status DeleteAVL(BSTree &T,ElemType e,int &shorter)//删除操作void merge(BSTree &T1,BSTree &T2)//合并操作void splitBSTree(BSTree T,ElemType e,BSTree &T1,BSTree &T2)//分裂操作void PrintBSTree(BSTree &T,int lev)//凹入表显示附录源代码：#include<stdio.h>#include<stdlib.h>//#define TRUE 1//#define FALSE 0//#define OK 1//#define ERROR 0#define LH +1#define EH 0#define RH -1//二叉类型树的类型定义typedef int Status;typedef int ElemType;typedef struct BSTNode{ElemType data;int bf;//结点的平衡因子struct BSTNode *lchild ,*rchild;//左、右孩子指针} BSTNode,* BSTree;/*查找算法*/Status SearchBST(BSTree T,ElemType e){if(!T){return 0; //查找失败}else if(e == T->data ){return 1; //查找成功}else if (e < T->data){return SearchBST(T->lchild,e);}else{return SearchBST(T->rchild,e);}}//右旋void R_Rotate(BSTree &p){BSTree lc; //处理之前的左子树根结点lc = p->lchild; //lc指向的*p的左子树根结点p->lchild = lc->rchild; //lc的右子树挂接为*P的左子树lc->rchild = p;p = lc; //p指向新的根结点}//左旋void L_Rotate(BSTree &p){BSTree rc;rc = p->rchild; //rc指向的*p的右子树根结点p->rchild = rc->lchild; //rc的左子树挂接为*p的右子树rc->lchild = p;p = rc; //p指向新的根结点}//对以指针T所指结点为根结点的二叉树作左平衡旋转处理，//本算法结束时指针T指向新的根结点void LeftBalance(BSTree &T){BSTree lc,rd;lc=T->lchild;//lc指向*T的左子树根结点switch(lc->bf){ //检查*T的左子树的平衡度，并做相应的平衡处理case LH: //新结点插入在*T的左孩子的左子树，要做单右旋处理T->bf = lc->bf=EH;R_Rotate(T);break;case RH: //新结点插入在*T的左孩子的右子树上，做双旋处理rd=lc->rchild; //rd指向*T的左孩子的右子树根switch(rd->bf){ //修改*T及其左孩子的平衡因子case LH: T->bf=RH; lc->bf=EH;break;case EH: T->bf=lc->bf=EH;break;case RH: T->bf=EH; lc->bf=LH;break;}rd->bf=EH;L_Rotate(T->lchild); //对*T的左子树作左旋平衡处理R_Rotate(T); //对*T作右旋平衡处理}}//右平衡旋转处理void RightBalance(BSTree &T){BSTree rc,ld;rc=T->rchild;switch(rc->bf){case RH:T->bf= rc->bf=EH;L_Rotate(T);break;case LH:ld=rc->lchild;switch(ld->bf){case LH: T->bf=RH; rc->bf=EH;break;case EH: T->bf=rc->bf=EH;break;case RH: T->bf = EH; rc->bf=LH;break;}ld->bf=EH;R_Rotate(T->rchild);L_Rotate(T);}}//插入结点Status InsertAVL(BSTree &T,ElemType e,int &taller){//taller反应T长高与否if(!T){//插入新结点，树长高，置taller为trueT= (BSTree) malloc (sizeof(BSTNode));T->data = e;T->lchild = T->rchild = NULL;T->bf = EH;taller = 1;}else{if(e == T->data){taller = 0;return 0;}if(e < T->data){if(!InsertAVL(T->lchild,e,taller))//未插入return 0;if(taller)//已插入到*T的左子树中且左子树长高switch(T->bf){//检查*T的平衡度，作相应的平衡处理case LH:LeftBalance(T);taller = 0;break;case EH:T->bf = LH;taller = 1;break;case RH:T->bf = EH;taller = 0;break;}}else{if (!InsertAVL(T->rchild,e,taller)){return 0;}if(taller)//插入到*T的右子树且右子树增高switch(T->bf){//检查*T的平衡度case LH:T->bf = EH;taller = 0;break;case EH:T->bf = RH;taller = 1;break;case RH:RightBalance(T);taller = 0;break;}}}return 1;}void DELeftBalance(BSTree &T){//删除平衡调整BSTree lc,rd;lc=T->lchild;switch(lc->bf){case LH:T->bf = EH;//lc->bf= EH;R_Rotate(T);break;case EH:T->bf = EH;lc->bf= EH;R_Rotate(T);break;case RH:rd=lc->rchild;switch(rd->bf){case LH: T->bf=RH; lc->bf=EH;break;case EH: T->bf=lc->bf=EH;break;case RH: T->bf=EH; lc->bf=LH;break;}rd->bf=EH;L_Rotate(T->lchild);R_Rotate(T);}}void DERightBalance(BSTree &T) //删除平衡调整{BSTree rc,ld;rc=T->rchild;switch(rc->bf){case RH:T->bf= EH;//rc->bf= EH;L_Rotate(T);break;case EH:T->bf= EH;//rc->bf= EH;L_Rotate(T);break;case LH:ld=rc->lchild;switch(ld->bf){case LH: T->bf=RH; rc->bf=EH;break;case EH: T->bf=rc->bf=EH;break;case RH: T->bf = EH; rc->bf=LH;break;}ld->bf=EH;R_Rotate(T->rchild);L_Rotate(T);}}void SDelete(BSTree &T,BSTree &q,BSTree &s,int &shorter){if(s->rchild){SDelete(T,s,s->rchild,shorter);if(shorter)switch(s->bf){case EH:s->bf = LH;shorter = 0;break;case RH:s->bf = EH;shorter = 1;break;case LH:DELeftBalance(s);shorter = 0;break;}return;}T->data = s->data;if(q != T)q->rchild = s->lchild;elseq->lchild = s->lchild;shorter = 1;}//删除结点Status Delete(BSTree &T,int &shorter){ BSTree q;if(!T->rchild){q = T;T = T->lchild;free(q);shorter = 1;}else if(!T->lchild){q = T;T= T->rchild;free(q);shorter = 1;}else{SDelete(T,T,T->lchild,shorter);if(shorter)switch(T->bf){case EH:T->bf = RH;shorter = 0;break;case LH:T->bf = EH;shorter = 1;break;case RH:DERightBalance(T);shorter = 0;break;}}return 1;}Status DeleteAVL(BSTree &T,ElemType e,int &shorter){ int sign = 0;if (!T){return sign;}else{if(e == T->data){sign = Delete(T,shorter);return sign;}else if(e < T->data){sign = DeleteAVL(T->lchild,e,shorter);if(shorter)switch(T->bf){case EH:T->bf = RH;shorter = 0;break;case LH:T->bf = EH;shorter = 1;break;case RH:DERightBalance(T);shorter = 0;break;}return sign;}else{sign = DeleteAVL(T->rchild,e,shorter);if(shorter)switch(T->bf){case EH:T->bf = LH;shorter = 0;break;case RH:T->bf = EH;break;case LH:DELeftBalance(T);shorter = 0;break;}return sign;}}}//合并void merge(BSTree &T1,BSTree &T2){int taller = 0;if(!T2)return;merge(T1,T2->lchild);InsertAVL(T1,T2->data,taller);merge(T1,T2->rchild);}//分裂void split(BSTree T,ElemType e,BSTree &T1,BSTree &T2){ int taller = 0;if(!T)return;split(T->lchild,e,T1,T2);if(T->data > e)InsertAVL(T2,T->data,taller);elseInsertAVL(T1,T->data,taller);split(T->rchild,e,T1,T2);}//分裂void splitBSTree(BSTree T,ElemType e,BSTree &T1,BSTree &T2){ BSTree t1 = NULL,t2 = NULL;split(T,e,t1,t2);T1 = t1;T2 = t2;return;}//构建void CreatBSTree(BSTree &T){int num,i,e,taller = 0;printf("输入结点个数:");scanf("%d",&num);printf("请顺序输入结点值\n");for(i = 0 ;i < num;i++){printf("第%d个结点的值",i+1);scanf("%d",&e);InsertAVL(T,e,taller) ;}printf("构建成功，输入任意字符返回\n");getchar();getchar();}//凹入表形式显示方法void PrintBSTree(BSTree &T,int lev){int i;if(T->rchild)PrintBSTree(T->rchild,lev+1);for(i = 0;i < lev;i++)printf(" ");printf("%d\n",T->data);if(T->lchild)PrintBSTree(T->lchild,lev+1);void Start(BSTree &T1,BSTree &T2){int cho,taller,e,k;taller = 0;k = 0;while(1){system("cls");printf(" 平衡二叉树操作的演示 \n\n");printf("********************************\n");printf(" 平衡二叉树显示区 \n");printf("T1树\n");if(!T1 )printf("\n 当前为空树\n");else{PrintBSTree(T1,1);}printf("T2树\n");if(!T2 )printf("\n 当前为空树\n");elsePrintBSTree(T2,1);printf("\n********************************************************************* *********\n");printf("T1操作：1.创建 2.插入 3.查找 4.删除 10.分裂\n");printf("T2操作：5.创建 6.插入 7.查找 8.删除 11.分裂\n");printf(" 9.合并 T1,T2 0.退出\n");printf("*********************************************************************** *******\n");printf("输入你要进行的操作：");scanf("%d",&cho);switch(cho){case 1:CreatBSTree(T1);break;case 2:printf("请输入要插入关键字的值");scanf("%d",&e);InsertAVL(T1,e,taller) ;break;case 3:printf("请输入要查找关键字的值");scanf("%d",&e);if(SearchBST(T1,e))printf("查找成功！\n");elseprintf("查找失败！\n");printf("按任意键返回87"); getchar();getchar();break;case 4:printf("请输入要删除关键字的值"); scanf("%d",&e);if(DeleteAVL(T1,e,k))printf("删除成功！\n");elseprintf("删除失败！\n");printf("按任意键返回");getchar();getchar();break;case 5:CreatBSTree(T2);break;case 6:printf("请输入要插入关键字的值"); scanf("%d",&e);InsertAVL(T2,e,taller) ;break;case 7:printf("请输入要查找关键字的值"); scanf("%d",&e);if(SearchBST(T2,e))printf("查找成功！\n");elseprintf("查找失败！\n");printf("按任意键返回");getchar();getchar();break;case 8:printf("请输入要删除关键字的值"); scanf("%d",&e);if(DeleteAVL(T2,e,k))printf("删除成功！\n");elseprintf("删除失败！\n");printf("按任意键返回");getchar();getchar();break;case 9:merge(T1,T2);T2 = NULL;printf("合并成功，按任意键返回"); getchar();getchar();break;case 10:printf("请输入要中间值字的值"); scanf("%d",&e);splitBSTree(T1,e,T1,T2) ;printf("分裂成功，按任意键返回"); getchar();getchar();break;case 11:printf("请输入要中间值字的值"); scanf("%d",&e);splitBSTree(T2,e,T1,T2) ;printf("分裂成功，按任意键返回"); getchar();getchar();break;case 0:system("cls");exit(0);}}}main(){BSTree T1 = NULL;BSTree T2 = NULL;Start(T1,T2);}。
数据结构能力测试集训题目
数据结构能力测试集训题目线性表1.实现顺序表各种基本运算的算法，并基础上设计一个主程序完成如下功能：(1)初始化顺序表L；(2)采用尾插法依次插入a，b，c，d，e；（3）输出顺序表L；（4）输出顺序表L的长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第3个元素；（7）输出元素a的位置；（8）在第四个元素位置上插入f元素；（9）输出顺序表L；（10）删除顺序表L的第3个元素；（11）输出顺序表L；（12）释放顺序表L。
2.实现单链表各种基本运算的算法，并基础上设计一个主程序完成如下功能：(1)初始化单链表h；(2)采用尾插法依次插入a，b，c，d，e；（3）输出单链表h；（4）输出单链表h的长度；（5）判断单链表h是否为空；（6）输出单链表h的第3个元素；（7）输出元素a的位置；（8）在第四个元素位置上插入f元素；（9）输出单链表h；（10）删除单链表h的第3个元素；（11）输出单链表h；（12）释放单链表h；3.实现双链表各种基本运算的算法，并基础上设计一个主程序完成如下功能：(1)初始化双链表h；(2)采用尾插法依次插入a，b，c，d，e；（3）输出双链表h；（4）输出双链表h的长度；（5）判断双链表h是否为空；（6）输出双链表h的第3个元素；（7）输出元素a的位置；（8）在第四个元素位置上插入f元素；（9）输出双链表h；（10）删除双链表h的第3个元素；（11）输出双链表h；（12）释放双链表h；4.实现循环单链表各种基本运算的算法，并基础上设计一个主程序完成如下功能：(1)初始化循环单链表h；(2)采用尾插法依次插入a，b，c，d，e；（3）输出循环单链表h；（4）输出循环单链表h的长度；（5）判断循环单链表h是否为空；（6）输出循环单链表h的第3个元素；（7）输出元素a的位置；（8）在第四个元素位置上插入f元素；（9）输出循环单链表h；（10）删除循环单链表h的第3个元素；（11）输出循环单链表h；（12）释放循环单链表h；5.实现循环单链表各种基本运算的算法，并基础上设计一个主程序完成如下功能：(1)初始化循环双链表h；(2)采用尾插法依次插入a，b，c，d，e；（3）输出循环双链表h；（4）输出循环双链表h的长度；（5）判断循环双链表h是否为空；（6）输出循环双链表h的第3个元素；（7）输出元素a的位置；（8）在第四个元素位置上插入f元素；（9）输出循环双链表h；（10）删除循环双链表h的第3个元素；（11）输出循环双链表h；（12）释放循环双链表h；6.求集合的并，交，差运算（用有序单链表表示）栈和队列7.实现顺序栈各种基本运算的算法，编写一个程序实现顺序栈的各种基本运算，并在此基础上设计一个主程序完成以下各种功能：（1）初始化栈s（2）判断栈s是否非空（3）依次进栈元素a，b，c，d，e（4）判断栈s是否非空（5）输出栈长度（6）输出从栈顶到栈底元素（7）输出出栈序列（8）判断栈s是否非空（9）释放栈8.实现链栈各种基本运算的算法，编写一个程序，实现链栈的各种基本算法，并在此基础上设计一个主程序完成如下功能：（1）初始化链栈s（2）判断链栈s是否非空（3）依次进栈元素a，b，c，d，e（4）判断链栈s是否非空（5）输出链栈长度（6）输出从栈顶到栈底元素（7）输出链栈序列（8）判断链栈s是否非空（9）释放链栈9.实现顺序队列各种基本运算的算法，编写一个程序，实现顺序循环队列各种基本运算，并在此基础上设计一个主程序完成如下功能：（1）初始化队列q（2）判断队列q是否非空（3）依次进队列元素a，b，c（4）出队一个元素，输出该元素（5）输出队列q的元素的个数（6）依次进队列元素d，e，f（7）输出队列q的元素的个数（8）输出出队序列（9）释放队列10.实现链队各种基本运算的算法，编写一个程序，实现链队的各种基本运算，在此基础上设计一个主程序完成如下功能：（1）初始化链队q（2）判断链队q是否非空（3）依次进链队元素a，b，c（4）出队一个元素，输出该元素（5）输出链队q的元素的个数（6）依次进链队元素d，e，f（7）输出链队q的元素的个数（8）输出出队序列（9）释放链队串11.实现顺序串各种基本运算的算法，编写一个程序实现顺序的基本运算的算法，比在此基础上设计一个主程序完成如下功能：（1）建立s=”abcdefghefghijklmn”和串s1=”xyz”（2）输出串s（3）输出串s的长度（4）在串s的第9个字符位置插入串s1而产生串s2（5）输出串s2（6）删除串s第2个字符开始的5个字符而产生的串s2（7）输出串s2（8）将串s第2个字符开始的5个字符替换成串s1而产生串s2（9）输出串s2（10）提取串s的第2个字符开始的10个字符而产生串s3（11）输出串s3（12）将串s1和串s2连接起来而产生的串s4（13）输出串s412.实现链串个各种基本运算的算法，编写一个程序实现链串的各种基本运算，并在此基础上设计一个主程序完成如下功能；（1）建立s=”abcdefghefghijklmn”和串s1=”xyz”（2）输出串s（3）输出串s的长度（4）在串s的第9个字符位置插入串s1而产生串s2（5）输出串s2（6）删除串s第2个字符开始的5个字符而产生的串s2（7）输出串s2（8）将串s第2个字符开始的5个字符替换成串s1而产生串s2（9）输出串s2（10）提取串s的第2个字符开始的10个字符而产生串s3（11）输出串s3（12）将串s1和串s2连接起来而产生的串s4（13）输出串s413.顺序串的各种模式匹配运算，编写一个程序实现顺序串的各种模式匹配运算，并在此基础上完成如下功能：（1）建立”abcabcdabcdeabcdefabcdefg”目标串s和”abcdeabcdefab”模式串t（2）采用简单匹配算法求t在s中的位置（3）由模式串t求出next值和nextval值（4）采用KMP算法求t在s中的位置（5）采用改进的KMP算法求t在s中的位置查找14.实现顺序查找的算法，编写一个程序输出在顺序表{3，6，2，10，1，8，5，7，4，9}中采用顺序方法查找关键字5的过程。
数据结构c语言课设-二叉树排序
题目:二叉排序树的实现1 内容和要求1）编程实现二叉排序树，包括生成、插入，删除；2）对二叉排序树进展先根、中根、和后根非递归遍历；3）每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。
4）分别用二叉排序树和数组去存储一个班(50 人以上)的成员信息(至少包括学号、姓名、成绩3 项),比照查找效率，并说明在什么情况下二叉排序树效率高,为什么?2 解决方案和关键代码2.1 解决方案：先实现二叉排序树的生成、插入、删除，编写DisplayBST函数把遍历结果用树的形状表示出来。
前中后根遍历需要用到栈的数据构造，分模块编写栈与遍历代码。
要求比照二叉排序树和数组的查找效率，首先建立一个数组存储一个班的成员信息，分别用二叉树和数组查找，利用clock〔〕函数记录查找时间来比照查找效率。
2.2关键代码树的根本构造定义及根本函数typedef struct{KeyType key;} ElemType;typedef struct BiTNode//定义链表{ElemType data;struct BiTNode *lchild, *rchild;}BiTNode, *BiTree, *SElemType;//销毁树int DestroyBiTree(BiTree &T){if (T != NULL)free(T);return 0;}//清空树int ClearBiTree(BiTree &T){if (T != NULL){T->lchild = NULL;T->rchild = NULL;T = NULL;}return 0;}//查找关键字,指针p返回int SearchBST(BiTree T, KeyType key, BiTree f, BiTree &p) {if (!T){p = f;return FALSE;}else if EQ(key, T->data.key){p = T;return TRUE;}else if LT(key, T->data.key)return SearchBST(T->lchild, key, T, p);elsereturn SearchBST(T->rchild, key, T, p);}二叉树的生成、插入，删除生成void CreateBST(BiTree &BT, BiTree p){int i;ElemType k;printf("请输入元素值以创立排序二叉树:\n");scanf_s("%d", &k.key);for (i = 0; k.key != NULL; i++){//判断是否重复if (!SearchBST(BT, k.key, NULL, p)){InsertBST(BT, k);scanf_s("%d", &k.key);}else{printf("输入数据重复！\n");return;}}}插入int InsertBST(BiTree &T, ElemType e){BiTree s, p;if (!SearchBST(T, e.key, NULL, p)){s = (BiTree)malloc(sizeof(BiTNode));s->data = e;s->lchild = s->rchild = NULL;if (!p)T = s;else if LT(e.key, p->data.key)p->lchild = s;elsep->rchild = s;return TRUE;}else return FALSE;}删除//某个节点元素的删除int DeleteEle(BiTree &p){BiTree q, s;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;if (q != p)q->rchild = s->lchild;elseq->lchild = s->lchild;delete s;}return TRUE;}//整棵树的删除int DeleteBST(BiTree &T, KeyType key) //实现二叉排序树的删除操作{if (!T){return FALSE;}else{if (EQ(key, T->data.key)) //是否相等return DeleteEle(T);else if (LT(key, T->data.key)) //是否小于return DeleteBST(T->lchild, key);elsereturn DeleteBST(T->rchild, key);}return 0;}二叉树的前中后根遍历栈的定义typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;int InitStack(SqStack &S) //构造空栈{S.base = (SElemType*)malloc(STACK_INIT_SIZE *sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}//InitStackint Push(SqStack &S, SElemType e) //插入元素e为新栈顶{if (S.top - S.base >= S.stacksize){S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT)*sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}*S.top++ = e;return OK;}//Pushint Pop(SqStack &S, SElemType &e) //删除栈顶,应用e返回其值{if (S.top == S.base) return ERROR;e = *--S.top;return OK;}//Popint StackEmpty(SqStack S) //判断是否为空栈{if (S.base == S.top) return TRUE;return FALSE;}先根遍历int PreOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S;BiTree p;InitStack(S);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);if (!Visit(p->data)) return ERROR;p = p->lchild;}else{Pop(S, p);p = p->rchild;}}return OK;}中根遍历int InOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S;BiTree p;InitStack(S);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);p = p->lchild;}else{Pop(S, p);if (!Visit(p->data)) return ERROR;p = p->rchild;}}return OK;}后根遍历int PostOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S, SS;BiTree p;InitStack(S);InitStack(SS);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);Push(SS, p);p = p->rchild;}else{if (!StackEmpty(S)){Pop(S, p);p = p->lchild;}}}while (!StackEmpty(SS)){Pop(SS, p);if (!Visit(p->data)) return ERROR;}return OK;}利用数组存储一个班学生信息ElemType a[] = { 51, "陈继真", 88,82, "黄景元", 89,53, "贾成", 88,44, "呼颜", 90,25, "鲁修德", 88,56, "须成", 88,47, "孙祥", 87, 38, "柏有患", 89, 9, " 革高", 89, 10, "考鬲", 87, 31, "李燧", 86, 12, "夏祥", 89, 53, "余惠", 84, 4, "鲁芝", 90, 75, "黄丙庆", 88, 16, "李应", 89, 87, "杨志", 86, 18, "李逵", 89, 9, "阮小五", 85, 20, "史进", 88, 21, "秦明", 88, 82, "杨雄", 89, 23, "刘唐", 85, 64, "武松", 88, 25, "李俊", 88, 86, "卢俊义", 88, 27, "华荣", 87, 28, "杨胜", 88, 29, "林冲", 89, 70, "李跃", 85, 31, "蓝虎", 90, 32, "宋禄", 84, 73, "鲁智深", 89, 34, "关斌", 90, 55, "龚成", 87, 36, "黄乌", 87, 57, "孔道灵", 87, 38, "张焕", 84, 59, "李信", 88, 30, "徐山", 83, 41, "秦祥", 85, 42, "葛公", 85, 23, "武衍公", 87, 94, "范斌", 83, 45, "黄乌", 60, 67, "叶景昌", 99, 7, "焦龙", 89, 78, "星姚烨", 85, 49, "孙吉", 90, 60, "陈梦庚", 95,};数组查询函数void ArraySearch(ElemType a[], int key, int length){int i;for (i = 0; i <= length; i++){if (key == a[i].key){cout << "学号：" << a[i].key << " 姓名：" << a[i].name << " 成绩：" << a[i].grade << endl;break;}}}二叉树查询函数上文二叉树根本函数中的SearchBST()即为二叉树查询函数。
二叉排序树的实验报告
二叉排序树的实验报告二叉排序树的实验报告引言：二叉排序树（Binary Search Tree，简称BST）是一种常用的数据结构，它将数据按照一定的规则组织起来，便于快速的查找、插入和删除操作。
本次实验旨在深入了解二叉排序树的原理和实现，并通过实验验证其性能和效果。
一、实验背景二叉排序树是一种二叉树，其中每个节点的值大于其左子树的所有节点的值，小于其右子树的所有节点的值。
这种特性使得在二叉排序树中进行查找操作时，可以通过比较节点的值来确定查找的方向，从而提高查找效率。
二、实验目的1. 理解二叉排序树的基本原理和性质；2. 掌握二叉排序树的构建、插入和删除操作；3. 验证二叉排序树在查找、插入和删除等操作中的性能和效果。
三、实验过程1. 构建二叉排序树首先，我们需要构建一个空的二叉排序树。
在构建过程中，我们可以选择一个节点作为根节点，并将其他节点插入到树中。
插入节点时，根据节点的值与当前节点的值进行比较，如果小于当前节点的值，则将其插入到当前节点的左子树中；如果大于当前节点的值，则将其插入到当前节点的右子树中。
重复这个过程，直到所有节点都被插入到树中。
2. 插入节点在已有的二叉排序树中插入新的节点时，我们需要遵循一定的规则。
首先，从根节点开始，将新节点的值与当前节点的值进行比较。
如果小于当前节点的值，则将其插入到当前节点的左子树中；如果大于当前节点的值，则将其插入到当前节点的右子树中。
如果新节点的值与当前节点的值相等，则不进行插入操作。
3. 删除节点在二叉排序树中删除节点时，我们需要考虑不同的情况。
如果要删除的节点是叶子节点，即没有左右子树，我们可以直接删除该节点。
如果要删除的节点只有一个子树，我们可以将子树连接到要删除节点的父节点上。
如果要删除的节点有两个子树，我们可以选择将其右子树中的最小节点或左子树中的最大节点替代该节点，并删除相应的替代节点。
四、实验结果通过对二叉排序树的构建、插入和删除操作的实验，我们得到了以下结果：1. 二叉排序树可以高效地进行查找操作。
数据结构实验指导书(新版)
《数据结构和算法》实验指导书实验及学时数分配序号实验名称学时数（小时）1 实验一线性表 42 实验二树和二叉树 23 实验三图 24 实验四查找 25 实验五内部排序 2合计12几点要求：一、上机前：认真预习相关实验内容，提前编写算法程序，上机时检查（未提前编写程序者，扣除平时成绩中实验相关分数）。
二、上机中：在Turbo C或VC6.0环境中，认真调试程序，记录调试过程中的问题、解决方法以及运行结果。
上机时签到；下机时验收签字。
三、下机后：按要求完成实验报告，并及时提交（实验后1周内）。
实验一线性表【实验目的】1、掌握用Turbo c上机调试线性表的基本方法；2、掌握线性表的基本操作，插入、删除、查找以及线性表合并等运算在顺序存储结构和链式存储结构上的运算；3、运用线性表解决线性结构问题。
【实验学时】4 学时【实验类型】设计型【实验内容】1、顺序表的插入、删除操作的实现；2、单链表的插入、删除操作的实现；3、两个线性表合并算法的实现。
(选做)【实验原理】1、当我们在线性表的顺序存储结构上的第i个位置上插入一个元素时，必须先将线性表中第i个元素之后的所有元素依次后移一个位置，以便腾出一个位置，再把新元素插入到该位置。
若是欲删除第i个元素时，也必须把第i个元素之后的所有元素前移一个位置；2、当我们在线性表的链式存储结构上的第i个位置上插入一个元素时，只需先确定第i个元素前一个元素位置，然后修改相应指针将新元素插入即可。
若是欲删除第i个元素时，也必须先确定第i个元素前一个元素位置，然后修改相应指针将该元素删除即可；3、详细原理请参考教材。
【实验步骤】一、用C语言编程实现建立一个顺序表，并在此表中插入一个元素和删除一个元素。
1、通过键盘读取元素建立线性表；（从键盘接受元素个数n以及n个整形数；按一定格式显示所建立的线性表）2、指定一个元素，在此元素之前插入一个新元素；（从键盘接受插入位置i，和要插入的元素值；实现插入；显示插入后的线性表）3、指定一个元素，删除此元素。
数据结构-二叉排序树
二叉排序树操作一、设计步骤1）分析课程设计题目的要求2）写出详细设计说明3）编写程序代码，调试程序使其能正确运行4）设计完成的软件要便于操作和使用5）设计完成后提交课程设计报告（一）程序功能：1）创建二叉排序树2）输出二叉排序树3）在二叉排序树中插入新结点4）在二叉排序树中删除给定的值5）在二叉排序树中查找所给定的值（二）函数功能：1） struct BiTnode 定义二叉链表结点类型包含结点的信息2） class BT 二叉排序树类，以实现二叉排序树的相关操作3） InitBitree() 构造函数，使根节点指向空4) ~BT () 析构函数，释放结点空间5) void InsertBST(&t,key) 实现二叉排序树的插入功能6) int SearchBST(t,key) 实现二叉排序树的查找功能7) int DelBST(&t,key) 实现二叉排序树的删除功能8) void InorderBiTree (t) 实现二叉排序树的排序（输出功能）9) int main() 主函数，用来完成对二叉排序树类中各个函数的测试二、设计理论分析方法（一）二叉排序树定义首先，我们应该明确所谓二叉排序树是指满足下列条件的二叉树：（1）左子树上的所有结点值均小于根结点值；（2）右子数上的所有结点值均不小于根结点值；（3）左、右子数也满足上述两个条件。
根据对上述的理解和分析，我们就可以先创建出一个二叉链表结点的结构体类型（struct BiTNode）和一个二叉排序树类（class BT），以及类中的构造函数、析构函数和其他实现相关功能的函数。
（二）插入函数（void InsertBST(&t,key)）首先定义一个与BiTNode<k> *BT同一类型的结点p，并为其申请空间，使p->data=key,p->lchild和p->rchild=NULL。
二叉排序树c语言代码实现
if ((*n) != NULL) {
free (*n);
*n = NULL;
}
}
/* 查找结点 */
PNODE find_node (PNODE n, int value) {
in_order_traversal ( n->right);
}
}
int main() {
char buf[50],a[1000];
int i,n,option,s[80],p;
PNODE tree = NULL;/*树的第一个结点*/
PNODE node = NULL;
{
r = (PNODE)malloc(sizeof(NODE));
if(!r)
{
printf("内存分配失败！");
exit(0);
zjm3:fgets (buf, sizeof(buf), stdin);
sscanf (buf, "%i", &option);
printf ("\n\n");
if(option<0) {
printf ("输入错误，请重新输入该元素\n",n);
goto zjm3;}
if(find_node (tree, option))
{
(*n)->value = value;
(*n)->left = NULL;
(*n)->right = NULL;
}
}
二叉排序树删除节点详解
⼆叉排序树删除节点详解⼆叉排序树删除节点详解说明1. ⼆叉排序树有着⽐数组查找快，⽐链表增删快的优势，⽐较常见2. ⼆叉排序树要删除节点，⾸先要找到该节点和该节点对应的⽗节点，因为只根据当前节点是不能删除节点本⾝的，因此需要找到⽗节点3. ⼆叉排序树删除节点，根据节点所在的位置不同，需要分为三种情况4. 即要删除的节点是叶⼦节点，要删除的节点只有⼀颗⼦树的情况和要删除的节点有两颗⼦树的情况5. 考虑第⼀种情况，即要删除的节点是叶⼦节点6. 直接找到要删除节点的⽗节点，然后置空即可7. 考虑第⼆种情况，即要删除的节点有⼀颗⼦树8. 先找到该节点和该节点的⽗节点，根据该节点是⽗节点的左⼦节点还是右⼦节点和该节点有左⼦节点还是有有⼦节点，应该分为四种情况讨论，每种情况改变⽗节点的引⽤即可实现删除9. 考虑第三种情况，即要删除的节点有两颗⼦树10. 这种情况删除思路应该为找到当前节点右⼦树的的最⼤值节点或者找到当前节点左⼦树的最⼩值节点，先将这个节点删除，再⽤这个节点替换当前节点11. 实质操作先记录删除⼦树的最⼤最⼩值节点的值，然后删除这个节点，最后⽤记录的这个值替换掉要删除的节点，实现删除有左右⼦树节点的思路12. 源码及思路见下源码及分析package algorithm.tree.bst;/*** @author AIMX_INFO* @version 1.0*/public class BinarySortTree {public static void main(String[] args) {int[] arr = {7, 3, 10, 12, 5, 1, 9, 2};BST bst = new BST();//循环添加节点for (int i = 0; i < arr.length; i++) {bst.add(new Node(arr[i]));}//中序遍历查看System.out.println("中序遍历");bst.infixOrder();System.out.println("删除叶⼦节点");bst.delNode(7);bst.infixOrder();}}//⼆叉排序树class BST {private Node root;//中序遍历public void infixOrder() {if (root != null) {root.infixOrder();} else {System.out.println("树是空的");}}//添加节点public void add(Node node) {if (root == null) {root = node;} else {root.add(node);}}//查找某⼀节点public Node search(int value) {if (root == null) {return null;} else {return root.search(value);}}//查找某⼀节点的⽗节点public Node searchParent(int value) {if (root == null) {return null;} else {return root.searchParent(value);}}//删除节点public void delNode(int value) {//先判断是否为空树if (root == null) {return;} else {//如果树不为空，再判断树是否只有⼀个空节点if (root.left == null && root.right == null && root.value == value) { root = null;return;}//否则先查找要删除的节点Node target = search(value);//判断要删除节点是否存在if (target == null) {return;}//如果存在则再找到要删除节点的⽗节点Node parent = searchParent(value);//然后根据要删除的节点分情况删除//如果要删除的节点是叶⼦节点if (target.left == null && target.right == null) {//判断target是⽗节点的左⼦节点还是右⼦节点//如果是左⼦节点if (parent.left != null && parent.left.value == value) {parent.left = null;}//如果是左⼦节点if (parent.right != null && parent.right.value == value) {parent.right = null;}//如果要删除的节点有两个⼦节点} else if (target.left != null && target.right != null) {int minVal = delRightNodeMin(target.right);target.value = minVal;//否则要删除的节点只有⼀个⼦节点} else {//判断要删除的节点有左⼦节点还是右⼦节点//target的左⼦节点不为空if (target.left != null){//判断target是⽗节点的左⼦树还是右⼦树//左⼦树if (parent != null) {if (parent.left.value == value) {parent.left = target.left;} else {//右⼦树parent.right = target.left;}}else {root = target.left;}//target的右⼦节点不为空}else {//同理if (parent != null) {if (parent.left.value == value) {parent.left = target.right;} else {parent.right = target.right;}}else {root = target.right;}}}}}/*** 查找当前⼆叉排序树的最⼩节点并删除* @param node 当前⼆叉排序树* @return 返回最⼩节点的值*/public int delRightNodeMin(Node node){//辅助变量⽤于遍历⼆叉排序树Node target = node;//循环查找最⼩节点while (target.left != null){target = target.left;}//循环结束时已经找到//删除当前节点delNode(target.value);//返回当前节点的值return target.value;}}//节点class Node {int value;Node left;Node right;public Node(int value) {this.value = value;}//查找某⼀节点/*** @param value 要查找的节点的值* @return 返回查找的结果*/public Node search(int value) {//如果要查找的节点就是当前节点，直接返回if (value == this.value) {return this;}//判断要查找的节点的value与当前节点的value的⼤⼩关系 //向左递归查找if (value < this.value) {//判断左⼦树是否为空if (this.left == null) {return null;}return this.left.search(value);} else {//向右递归查找//判断右⼦树是否为空if (this.right == null) {return null;}return this.right.search(value);}}//查找要删除节点的⽗节点/*** @param value 要删除的节点的值* @return 返回查找的结果*/public Node searchParent(int value) {//判断当前节点是不是要查找节点的⽗节点if ((this.left != null && this.left.value == value) ||(this.right != null && this.right.value == value)) {return this;} else {//如果不是则向左向右递归查找//向左递归if (value < this.value && this.left != null) {return this.left.searchParent(value);//向右递归} else if (value >= this.value && this.right != null) {return this.right.searchParent(value);} else {//否则没有找到return null;}}}//递归添加节点的⽅法public void add(Node node) {//数据校验if (node == null) {return;}//根据要添加的节点的值和当前节点值的⼤⼩判断节点要添加的位置 if (node.value < this.value) {//如果当前左⼦节点为空，则直接添加if (this.left == null) {this.left = node;} else {//否则递归添加this.left.add(node);}} else {//同理if (this.right == null) {this.right = node;} else {this.right.add(node);}}}//中序遍历public void infixOrder() {if (this.left != null) {this.left.infixOrder();}System.out.println(this);if (this.right != null) {this.right.infixOrder();}}@Overridepublic String toString() {return "Node{" +"value=" + value +'}';}}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
二叉排序树的基本操作的实现————————————————————————————————作者: ————————————————————————————————日期:二叉排序树的基本操作的实现一设计要求1.问题描述从磁盘读入一组数据,建立二叉排序树并对其进行查找、、遍历、插入、删除等基本操作。
2.需求分析建立二叉排序树并对其进行查找,包括成功和不成功两种情况。
二概要设计为了实现需求分析中的功能,可以从以下3方面着手设计。
1.主界面设计为了方便对二叉排序树的基本操作，设计一个包含多个菜单选项的主控制子程序以实现二叉排序树的各项功能。
本系统的主控制菜单运行界面如图1所示。
图1二叉排序树的基本操作的主菜单2.存储结构的设计本程序主要采二叉树结构类型来表示二叉排序树。
其中二叉树节点由1个表示关键字的分量组成,还有指向该左孩子和右孩子的指针。
3.系统功能设计本程序设置了5个子功能菜单，其设计如下。
1)建立二叉排序树。
根据系统提示,输入节点的关键字,并以0作为结束的标识符。
该功能由Bｓtｒee Creａte（)函数实现。
2)插入二叉排序新的节点信息。
每次只能够插入一个节点信息，如果该节点已经存在,则不插入。
该功能由Bstree Inｓerｔ(y)函数实现。
3)查询二叉排序树的信息。
每次进行查询,成功则显示“查询到该节点”,不成功则“显示查询不到该节点“该功能由Ｂsｔree Seaｒcｈ()函数实现。
4)删除二叉排序树的节点信息。
可以对二叉排序树中不需要的节点进行删除，删除的方式是输入关键字，查询到该节点后删除。
该功能由ＢｓtreeＤelete()函数实现。
5)遍历二叉排序树。
遍历二叉排序树可以显示该二叉排序树的全部节点信息。
该功能由ｖoｉd Ｔraveｒse()实现。
三模块设计1.模块设计本程序包含两个模块:主程序模块和二叉排序树操作模块。
其调用关系如图2图2模块调用示意图2. 系统子程序及其功能设计本系统共设计了5个子程序,个程序的的函数名及其功能说明如下：1) Bstr ｅe Cr ｅa ｔe （); /／创建二叉排序树2) Bs ｔｒee I ｎsert(Bst ｒｅｅ ｔree,i ｎt key); ／/插入3) Bst ｒee Search （Bstree tree ，i ｎt key); ／／查找4) vo ｉｄ Ｔraverse （Ｂst ｒｅe tree); //遍历5) Bst ｒee Delete(Ｂs ｔｒee tr ｅe,i ｎt ｋe ｙ)； //删除信息3. 函数主要的调用关系图本系统9个子程序见的主要调用关系图3.四 详细设计1. 数据类型定义本系统采用二叉树结构存储节点信息,节点定义如下：ｔypede ｆ struct Bstno ｄe{ﻩint ｋey;ﻩs ｔｒuc ｔ B ｓt ｎｏde ＊lchild,*ｒchild;}Ｂstnode,＊ Bst ｒｅe;2. 主要子程序的详细设计1) 二叉排序树的创建函数，主要用来建立二叉排序树。
Bs ｔree Cre ａt ｅ(){ｉnt key; 主程序模二叉排序树Main(Main()Inser Searc Trave DeletﻩBsｔrｅe tree=NULＬ; //初始化空树sｃａnf("%ｄ＂,&ｋey)；ﻩwｈｉle（keｙ!=0)ﻩ{ﻩｔree＝Ｉnserｔ(tree,kｅy）；//逐个插入节点ﻩscaｎf("%ｄ",&key）；ﻩ}ﻩreturｎtｒee;}2)二叉排序插入函数如下：Bｓｔree Iｎsert(Bstreｅｔrｅｅ，int key)｛Bsｔreeｐ=treｅ;ﻩBｓｔｒｅe s,f;while (p!=ＮＵLL）ﻩ｛ﻩf=p;ﻩiｆ(key＝＝p->kｅy)retｕrn tree;ﻩｉf(kｅy＜p->key）ｐ＝p-＞ｌｃhild;ﻩelsｅp=p->ｒchiｌd;}s=（Ｂstree)ｍaｌloc(ｓｉzeoｆ(Ｂstnode）);ﻩs-＞keｙ＝ｋey；ﻩs->lchild=NＵＬL;ｓ－>ｒcｈiｌd=ＮUＬL;ﻩｉf（trｅe=＝NULL)return s;//新节点为二叉排序树的根ﻩif(kｅy<f->key)f->lｃhild=s;eｌsｅｆ->ｒchilｄ=s;ﻩretｕrn ｔrｅe；}3)二叉排序树查询函数如下:Bstree Search(Bsｔｒｅｅtree，ｉntｋey){Ｂstrｅｅp＝trｅe;ｉnt flag=０；whiｌe(ｐ!=NUＬL）｛ﻩﻩiｆ(ｐ－＞key=＝ｋey)ﻩ{printf(＂查询到该节点!");ﻩｆlａg=１;ﻩﻩｒeturｎ(p);ﻩbrｅak;}if (ｋey<p-＞key) p=p->lｃｈｉld;ﻩeｌｓｅp＝p->rcｈild;}iｆ(ｆlaｇ=＝0）ﻩ{ﻩprｉntf（"查询不到关键字为%d的节点！",ｋeｙ）;ﻩﻩreturn NULL;ﻩ}｝五测试分析1.二叉排序树的建立首先进入主菜单，如图１。
在主菜单下,用户根据菜单的选项输入1，然后按照提示建立二叉排序树，并以0未结束符。
运行的结果如图4．图4二叉排序树的建立2.遍历二叉树的节点信息在主菜单下，用户选择4，可以打印出全部的节点信息。
运行的结果如图5.图5遍历二叉排序树3.插入节点信息信息在主菜单下，用户选择2,可以插入一个新的节点信息。
运行的结果如图6.图６插入新的节点4.查询二叉树的节点信息在主菜单下，用户选择３，首先通过输入关键字查询相关信息。
运行的结果如图７.图７查询节点信息5.删除二叉树的节点在主菜单下,用户选择5，可以通过输入要删除的关键字来删除该节点的全部信息。
运行的结果如图8.图８删除二叉排序树的节点6.退出在主菜单下，用户输入6并回车，即退出“二叉树基本操作程序”。
六原程序清单＃ｉnclｕde<stｄio．h>#inｃlude<ｓtｄlib.h＞#inｃlude＜malloｃ.h＞/**＊＊*＊二叉排序树的数据结构********/tyｐｅdeｆstｒuｃt Bｓtnode｛ﻩiｎt key;stｒuct Bstｎｏde＊lｃhｉld,＊ｒcｈｉlｄ;}Bstｎode，* Bｓｔree;Bstree Ｃｒeate（)；//创建二叉排序树Bｓtree Inserｔ(Ｂｓtreeｔree,int key); //插入BstｒeeＳeａrcｈ（Bstｒee ｔree,int key); /／查找void Traveｒse(Bstree tｒee）; //遍历Ｂｓtree Dｅlｅte(Bstｒｅe tree,int key); //删除/*******＊＊***＊********创建二叉排序树******＊*******/BｓｔreｅCrｅａte()｛ｉnｔkey;ﻩＢstree treｅ=NULL; /／初始化空树ﻩscａnf（"%d",&key);ﻩwhilｅ（key!=0){treｅ=Insert(tｒee,key）; /／逐个插入节点ﻩｓcanｆ("%d",&key）;ﻩ｝ﻩretｕrｎｔree;｝/****＊***＊*＊＊＊＊＊＊**＊插入＊*＊**＊******＊****＊**＊/Bstree Iｎseｒｔ(Bstree tree,iｎt ｋey){Bstrｅe p=tｒee;ﻩBsｔｒeｅs,f；ﻩwhile (ｐ！=NULL)ﻩ{ﻩﻩf=ｐ;ﻩｉf(key=＝p－>keｙ) reｔurn trｅｅ;ﻩｉf(keｙ＜ｐ->ｋｅy) ｐ=p->lｃhild;ﻩelse p=p->rｃhiｌd;ﻩ}ｓ＝(Bstreｅ)mａlloc(sizeｏf(Ｂstnoｄe)）;s－>key＝kｅy;ﻩs-＞lｃhilｄ=NUＬL;ﻩs->ｒｃhilｄ=NULL;ﻩｉf（treｅ==NULＬ）return s; /／新节点为二叉排序树的根if(ｋey<f－>key) f->lchilｄ=s;ﻩelse ｆ-＞ｒchｉld=ｓ；ﻩretｕrｎtree;}／＊*＊**＊*＊＊＊*＊**查找**＊********＊＊*/Bstree Seaｒｃh(Ｂｓｔｒee tｒｅe,int keｙ）{ﻩBsｔreeｐ=treｅ;inｔflag=0;while(p!=ＮULL)ﻩ{ﻩif(p->key==key){ﻩprinｔf（＂查询到该节点!")；ﻩﻩfｌaｇ=1;ﻩﻩreturｎ(p）;ﻩﻩｂreaｋ;ﻩ}if (ｋｅy<p-＞keｙ）ｐ＝p-＞ｌｃhｉld；ﻩﻩelse p=p-＞rｃhilｄ;ﻩ}if(fｌag==0）ﻩ{ﻩﻩprｉntf（"查询不到关键字为%d的节点!",key);ﻩﻩｒetｕrnＮUＬL;ﻩ｝｝/＊****＊＊*＊******遍历**＊*******＊*＊*＊****＊*／vｏid Trａvｅrse（Bstree tｒeｅ）{iｆ（tree）ﻩ{ﻩTraverse（tｒeｅ->lchｉld);pｒinｔf("%4d＂,tree->ｋｅｙ);ﻩＴraversｅ(tｒee－>ｒｃhild);ﻩ}}/**＊*＊**＊*****＊＊删除*＊**＊**＊*＊*******＊*/ＢstreｅDelｅte(Bstｒee tree,int key)｛ﻩBsｔreeｐ=trｅe;Bstrｅｅf，s,q；ｆ=NUＬL;ﻩｗhｉle（p){ //查找关键字为ｋeｙ的节点ﻩｉｆ(p－>key==key) ｂrｅａk;ﻩf=p;ﻩiｆ(p-＞key＞ｋey) ｐ＝p-＞lchilｄ;ﻩelse p=p->rｃｈild;}ﻩif（p==NＵLL)ｒｅｔurn trｅe;iｆ((p-＞ｌｃhilｄ==NULＬ)||(p－＞rchiｌｄ==NULL))｛if（f==ＮULL)ﻩif(p->ｌｃhiｌd==NULL)treｅ=ｐ-＞ｒchild;ﻩelｓe trｅe＝p-＞lｃhilｄ;ﻩeｌse if (p－＞lchilｄ==ＮULＬ)ﻩﻩif(f-＞ｌchild＝＝p) f->lchiｌd=ｐ－>rｃhild;ﻩﻩelsｅｆ->rｃhiｌd=p->rchild;ﻩelse ｉf（f->ｌchilｄ==p) f－>lcｈiｌｄ=ｐ-＞lchiｌd;else f－>ｌchiｌｄ=p->lchiｌｄ;ﻩfree（p）;}ﻩelse{ｑ=p;s=p->ｌchild;ﻩｗhiｌe(s->rchiｌd)ﻩ{ﻩﻩﻩq＝ｓ；s=ｓ－>rchild;ﻩ}if(ｑ=＝p) q->lcｈild=s－>lｃｈild;ﻩｐ－>key=s－>key；ﻩfrｅｅ(ｓ);ﻩ｝ｒetuｒn tｒee;}/*********＊***＊*******＊***＊************＊＊**＊/voｉd main（)｛ｓysｔeｍ(＂cｏlor １E");ﻩBstree tｒｅe,p；iｎt key1，key２,ｋey3;ﻩint select,ｆｌag;ｐrｉｎtf("##＃#########＃#############＃#＃##＃＃##＃##＃##＃#＃＼n＂)；ﻩpｒiｎtf("｜* 欢迎您使用本系统*|\n"）;ﻩpriｎtf("|＊*＊***＊**＊*＊***＊＊**＊**＊**＊****＊***＊*******｜\ｎ＂）；pｒintf（"｜* １.创建二叉排序树*|＼n＂）;ﻩpriｎtf（"|＊ 2.插入＊|\n＂);priｎｔｆ(＂|*3．查找*｜＼n＂); ﻩpriｎtｆ("|* 4.遍历＊|\n"）；ｐrｉntf("|＊ 5.删除*|＼n＂);printf(＂|＊６．退出*|＼n");priｎtf（"**＊*＊*＊***＊**＊******＊*******＊＊**＊＊＊******＊*＊\n");whilｅ(select!＝６)ﻩ{ﻩｐrintf("选择的功能:＂）;ｓcaｎf（＂%d",＆selecｔ);switｃｈ(select）ﻩ {ﻩﻩｃaｓe 1: printｆ("请输入节点信息(0为结束符）:\n");ﻩｔrｅe＝Crｅａte();ｐrintｆ("\n＂);ﻩﻩﻩbreak;casｅ2:printf（＂插入一个新的节点:"）;ﻩﻩｓcaｎf("%ｄ＂,&keｙ1）;Iｎserｔ(ｔree,keｙ１);ﻩprｉnｔf（"插入后得序列为:＼n＂);ﻩﻩTｒavｅrse(treｅ）；ﻩprｉntf("\n");bｒeak；ﻩcase３: pｒiｎｔf（"输入查找的数据:"）;ﻩﻩscanf("%d"，＆key２);p=Search(tree,kｅy2);ﻩｐrｉｎｔf(＂\n")；ﻩbreak;case ４: pｒintｆ("遍历所得序列为:＼n"）;ﻩﻩTraveｒsｅ(trｅe);pｒinｔf(＂＼n＂);ﻩﻩbreak;ﻩ case5:printｆ("输入删除的数据:"）;ﻩﻩﻩsｃanｆ("％d",＆ｋeｙ3);tｒee=Deletｅ（trｅe,keｙ3)；prinｔf("删除后遍历所得序列：\n"）;ﻩTraｖｅrｓe(trｅｅ);pｒintf("＼n＂);brｅaｋ;case 6: prｉntｆ("谢谢您的使用，再见！\n"）;flag=0;bｒeａk；defａult:priｎｔf（＂输入错误，请重新输入＼ｎ＂);brｅak;ﻩ}ﻩ}｝七用户手册运行程序进入本系统后,及显示系统的主菜单。