数据结构程序报告平衡二叉树的操作.docx
《数据结构程序报告平衡二叉树的操作.docx》由会员分享，可在线阅读，更多相关《数据结构程序报告平衡二叉树的操作.docx（20页珍藏版）》请在冰豆网上搜索。
数据结构程序报告平衡二叉树的操作
计算机科学学院数据结构课程设计报告
平衡二叉树操作
学生姓名：
学号：
班级：
指导老师：
报告日期：
1.需求分析
1．建立平衡二叉树并进行创建、查找、插入、删除等功能。
2．设计一个实现平衡二叉树的程序，可进行创建、查找、插入、删除等操作，实现动态的输入数据，实时的输出该树结构。
3．测试数据：
自选数据
2.概要设计
1.抽象数据类型定义：
typedefstructBSTNode{
intdata;
intbf;//节点的平衡因子
structBSTNode*lchild,*rchild;//左右孩子指针
}BSTNode,*BSTree;
voidCreatBST（BSTree&T）;//创建平衡二叉树
voidR_Rotate（BSTree&p）;//对以*p为根的二叉排序树作左旋处理
voidL_Rotate（BSTree&p）;//对以*p为根的二叉排序树作左旋处理
voidLeftBalance（BSTree&T）;//对以指针Ｔ所指结点为根的二叉树作左平衡旋转处理
voidRightBalance（BSTree&T）;//对以指针Ｔ所指结点为根的二叉树作右平衡旋转处理
boolInsertAVL（BSTree&T,inte,bool&taller）;//插入结点e
boolSearchBST（BSTree&T,intkey）;//查找元素key是否在树T中
voidLeftBalance_div（BSTree&p,int&shorter）;//删除结点时左平衡旋转处理
voidRightBalance_div（BSTree&p,int&shorter）;//删除结点时右平衡旋转处理
voidDelete（BSTreeq,BSTree&r,int&shorter）;//删除结点
intDeleteAVL（BSTree&p,intx,int&shorter）;//平衡二叉树的删除操作
voidPrintBST（BSTreeT,intm）;//按树状打印输出二叉树的元素
2.主程序的流程
请输入操作的选项编号（1-5）
1---创建平衡二叉树
2---查找
3---插入
4---删除
5---结束
3.各模块之间的层次调用
插入
退出
输出
删除
主模块
查找
显示主菜单
输入数据元素
平衡化
3.详细设计
1.以平衡二叉树的插入和平衡化为例：
boolInsertAVL（BSTree&T,inte,bool&taller）
{
//若存在平衡的二叉排序树T中不存在和e有相同关键字的节点，则插入一个数据元素为e
//的新结点，并返回1，否者返回0。
若因插入而使二叉排序树失去平衡，则作平衡旋转理，
//布尔变量taller反映T长高与否。
if（!
T）//插入新结点，树“长高”，置taller为true
{
T=（BSTree）malloc（sizeof（BSTNode））;
T->data=e;
T->lchild=T->rchild=NULL;
T->bf=EH;taller=true;
}
else
{
if（EQ（e,T->data））//树中已存在和有相同关键字的结点
{taller=false;printf（"已存在相同关键字的结点\n"）;return0;}//则不再插入
if（LT（e,T->data））//应继续在*T的左子树中进行搜索
{
if（!
InsertAVL（T->lchild,e,taller））return0;//未插入
if（taller）//已插入到*T的左子树中且左子树“长高”
switch（T->bf）//检查*T的平衡度
{
caseLH:
//原本左子树比右子树高，需要作左平衡处理
LeftBalance（T）;taller=false;break;
caseEH:
//原本左子树、右子等高，现因左子树增高而使树增高
T->bf=LH;taller=true;break;
caseRH:
//原本右子树比左子树高，现左、右子树等高
T->bf=EH;taller=false;break;
}//switch（T->bf）
}//if
else//应继续在*T的右子树中进行搜索
{
if（!
InsertAVL（T->rchild,e,taller））return0;//未插入
if（taller）//已插入到*T的右子树中且右子树“长高”
switch（T->bf）//检查*T的平衡度
{
caseLH:
//原本左子树比右子树高，现左、右子树等高
T->bf=EH;taller=false;break;
caseEH:
//原本左子树、右子等高，现因右子树增高而使树增高
T->bf=RH;taller=true;break;
caseRH:
//原本右子树比左子树高，需要作右平衡处理
RightBalance（T）;taller=false;break;
}//switch（T->bf）
}//else
}//else
return1;
}//InsertAVL
2.说明：
执行完输入函数后，会在键盘缓冲区中保存回车键，后面再对字符型量
赋值时，会将缓冲区当成数据存入变量中，所以要在某些输入语句后面加getchar
函数。
4.调试分析
1.遇到的问题：
（1）对平衡二叉树的删除的算法设计程序存在很大问题。
删除节点后需要对新的排序树平衡化，改变节点的信息，使之形成一棵新的平衡二叉树。
（2）主函数中的实参和子函数中的实参相等，造成调用该子函数时，虽然没有错误，但其功能不能正确的实现。
改变该变量后程序成功实现各种功能。
（3）一些逻辑逻辑运算符书写不正确，造成实现的功能不正确或程序死循环。
……
2.收获：
（1）对平衡二叉树的构造、插入和删除的算法思想有了更清楚的认识，能够对平衡二叉树进行创建、调平、插入、删除等操作，实现动态的输入数据，实时的输出该树结构.
（2）对多个程序的调用
5.用户使用说明
1.了解程序清单上给出的功能，并根据提示依次进行操作。
2.创建二叉树，输入的数据元素为整数，当输入-123时，停止创建。
并显示平衡二叉树的中序凹入树形图。
3.查找（输入你要查找的元素）。
4.插入（输入要插入的数据元素，并输出）
5.删除（删除指定的元素，并输出）
6.结束
说明：
其中每一个功能实现后都会提示是否继续：
选择y继续，否则，终止。
6.测试结果
1.创建平衡二叉树：
（中序凹入输出）
2.查找
查找成功或失败时：
3.插入
4.删除,结束
7.附录
源代码：
#include
#include
#defineLH+1
#defineEH0
#defineRH-1
#defineNULL0
typedefstructBSTNode{
intdata;
intbf;
structBSTNode*lchild,*rchild;
}BSTNode,*BSTree;
voidCreatBST（BSTree&T）;
voidR_Rotate（BSTree&p）;
voidL_Rotate（BSTree&p）;
voidLeftBalance（BSTree&T）;
voidRightBalance（BSTree&T）;
boolInsertAVL（BSTree&T,inte,bool&taller）;
boolSearchBST（BSTree&T,intkey）;
voidLeftBalance_div（BSTree&p,int&shorter）;
voidRightBalance_div（BSTree&p,int&shorter）;
voidDelete（BSTreeq,BSTree&r,int&shorter）;
intDeleteAVL（BSTree&p,intx,int&shorter）;
voidPrintBST（BSTreeT,intdepth）;
voidmain（）
{
BSTreeT;
intsear,cmd,depth;
charch;
intshorter=0;
booltaller=false;
T=（BSTree）malloc（sizeof（BSTNode））;
T=NULL;
printf（"****************平衡二叉树的操作菜单****************\n"）;
printf（"1--创建\n"）;
printf（"2--查找\n"）;
printf（"3--插入\n"）;
printf（"4--删除\n"）;
printf（"5--退出\n"）;
printf（"****************************************************\n"）;
do
{
printf（"\n请选择操作的编号：
"）;
scanf（"%d",&cmd）;
getchar（）;
switch（cmd）
{
case1:
CreatBST（T）;break;
case2:
printf（"请输入您要查找的关键字：
"）;
scanf（"%d",&sear）;getchar（）;
if（SearchBST（T,sear））printf（"关键字%d存在，查找成功!
\n",sear）;
elseprintf（"查找失败!
\n"）;
break;
case3:
printf（"请输入您要插入的关键字：
"）;
scanf（"%d",&sear）;getchar;
InsertAVL（T,sear,taller）;depth=0;
PrintBST（T,depth）;
break;
case4:
depth=0;
printf（"请输入你要删除的关键字:
"）;
scanf（"%d",&sear）;getchar（）;
DeleteAVL（T,sear,shorter）;
PrintBST（T,depth）;
break;
case5:
printf（"结束!
\n"）;
break;
default:
printf（"输入错误!
\n"）;
}
if（cmd==5）
break;
printf（"\n继续吗?
y/n:
"）;
scanf（"%s",&ch）;
getchar（）;
printf（"\n"）;
}while（ch=='y'）;
printf（"\n"）;
}
voidCreatBST（BSTree&T）
{
intdepth;
inte;
booltaller=false;
T=NULL;
printf（"\n请输入关键字（以-123结束建立平衡二叉树）:
"）;
scanf（"%d",&e）;
getchar（）;
while（e!
=-123）
{
InsertAVL（T,e,taller）;
printf（"\n请输入关键字（以-123结束建立平衡二叉树）:
"）;
scanf（"%d",&e）;
getchar（）;
taller=false;
}
depth=0;
printf（"\n****************************************************\n"）;
printf（"您创建的二叉树为\n"）;
if（T）
PrintBST（T,depth）;
else
printf（"这是一棵空树!
\n"）;
}
voidR_Rotate（BSTree&p）//对以*p为根的二叉排序树作右旋处理
{
BSTreelc;
lc=p->lchild;
p->lchild=lc->rchild;
lc->rchild=p;
p=lc;
}
voidL_Rotate（BSTree&p）//对以*p为根的二叉排序树作左旋处理
{
BSTreerc;
rc=p->rchild;
p->rchild=rc->lchild;
rc->lchild=p;
p=rc;
}
voidLeftBalance（BSTree&T）//对以指针Ｔ所指结点为根的二叉树作左平衡旋转处理
{
BSTreelc,rd;
lc=T->lchild;
switch（lc->bf）
{
caseLH:
T->bf=lc->bf=EH;
R_Rotate（T）;
break;
caseRH:
rd=lc->rchild;
switch（rd->bf）
{
caseLH:
T->bf=RH;lc->bf=EH;break;
caseEH:
T->bf=lc->bf=EH;break;
caseRH:
T->bf=EH;lc->bf=LH;break;
}
rd->bf=EH;
L_Rotate（T->lchild）;
R_Rotate（T）;
}
}
voidRightBalance（BSTree&T）//对以指针Ｔ所指结点为根的二叉树作右平衡旋转处理
{
BSTreerc,ld;
rc=T->rchild;
switch（rc->bf）
{
caseRH:
T->bf=rc->bf=EH;
L_Rotate（T）;
break;
caseLH:
ld=rc->lchild;
switch（ld->bf）
{
caseRH:
T->bf=LH;rc->bf=EH;break;
caseEH:
T->bf=rc->bf=EH;break;
caseLH:
T->bf=EH;rc->bf=RH;break;
}
ld->bf=EH;
R_Rotate（T->rchild）;
L_Rotate（T）;
}
}
boolInsertAVL（BSTree&T,inte,bool&taller）//插入结点e
{
if（!
T）
{
T=（BSTree）malloc（sizeof（BSTNode））;
T->data=e;
T->lchild=T->rchild=NULL;
T->bf=EH;
taller=true;
}
else{
if（e==T->data）
{
taller=false;
printf（"已存在相同关键字的结点!
\n"）;
return0;
}
if（edata）
{
if（!
InsertAVL（T->lchild,e,taller））
return0;
if（taller）
switch（T->bf）
{
caseLH:
LeftBalance（T）;taller=false;break;
caseEH:
T->bf=LH;taller=true;break;
caseRH:
T->bf=EH;taller=false;break;
}
}
else{
if（!
InsertAVL（T->rchild,e,taller））
return0;
if（taller）
switch（T->bf）
{
caseLH:
T->bf=EH;taller=false;break;
caseEH:
T->bf=RH;taller=true;break;
caseRH:
RightBalance（T）;taller=false;break;
}
}
}
}
boolSearchBST（BSTree&T,intkey）//查找元素key是否在树Ｔ中
{
if（!
T）
returnfalse;
elseif（key==T->data）
returntrue;
elseif（keydata）
returnSearchBST（T->lchild,key）;
else
returnSearchBST（T->rchild,key）;
}
voidLeftBalance_div（BSTree&p,int&shorter）//删除结点时左平衡旋转处理
{
BSTreep1,p2;
if（p->bf==1）
{p->bf=0;shorter=1;}
elseif（p->bf==0）
{p->bf=-1;shorter=0;}
else
{
p1=p->rchild;
if（p1->bf==0）
{
L_Rotate（p）;
p1->bf=1;p->bf=-1;shorter=0;
}
elseif（p1->bf==-1）
{
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;}
elseif（p2->bf==-1）
{p->bf=1;p1->bf=0;}
else
{p->bf=0;p1->bf=-1;}
p2->bf=0;p=p2;shorter=1;
}
}
}
voidRightBalance_div（BSTree&p,int&shorter）//删除结点时右平衡旋转处理
{
BSTreep1,p2;
if（p->bf==-1）
{p->bf=0;shorter=1;}
elseif（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;
}
elseif（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;}
elseif（p2->bf==1）
{p->bf=-1;p1->bf=0;}
else
{p->bf=0;p1->bf=1;}
p2->bf=0;p=p2;shorter=1;
}
}
}
voidDelete（BSTreeq,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）
RightBalance_div（r,shorter）;
}
}
intDeleteAVL（BSTree&p,intx,int&shorter）//平衡二叉树的删除操作
{
intk;
BSTreeq;
if（p==NULL）{printf（"不存在要删除的关键字!
\n"）;return0;}
elseif（xdata）
{
k=DeleteAVL（p->lchild,x,shorter）;
if（shorter==1）
LeftBalance_div（p,shorter）;
returnk;
}
elseif（x>p->data）
{
k=DeleteAVL（p->rchild,x,shorter）;
if（shorter==1）
RightBalance_div（p,shorter）;
returnk;
}
else
{
q=p;
if（p->rchild==NULL）
{p=p->lchild;free（q）;shorter=1;}
elseif（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;
}
return1;
}
}
voidPrintBST（BSTreeT,intdepth）
{
inti;
if（T->rchild）
PrintBST（T->rchild,depth+1）;
for（i=1;i<=depth;i++）
printf（""）;
printf（"%d\n",T->data）;
if（T->lchild）
PrintBST（T->lchild,depth+1）;
}
升级会员 