平衡二叉树AVL的查找插入和删除.docx

平衡二叉树AVL的查找插入和删除.docx

《平衡二叉树AVL的查找插入和删除.docx》由会员分享，可在线阅读，更多相关《平衡二叉树AVL的查找插入和删除.docx（31页珍藏版）》请在冰豆网上搜索。

平衡二叉树AVL的查找插入和删除

平衡二叉树（AVL）

查找、插入和删除

小组成员：

陈静101070009

陈丹璐101070006

陈娇101070008

问题描述

利用平衡二叉树实现一个动态查找表。

（1）实现动态查找表的三种基本功能：

查找、插入和删除。

（2）初始时，平衡二叉树为空树，操作界面给出创建、查找、插入和删除和退出五种操作供选择。

每种操作均要提示输入关键字。

创建时，根据提示输入数据，以-1为输入数据的结束标志，若输入数据重复，则给出已存在相同关键字的提示，并不将其插入到二叉树中。

在查找时，如果查找的关键字不存在，则显示不存在查找的关键字，若存在则显示存在要查找的关键字。

插入时首先检验原二叉树中是否已存在相同第2页共16页-2-的关键字，若没有则进行插入并输出二叉树，若有则给出已有相同关键字的提醒。

删除时首先检验原二叉树中是否存在要删除的关键字，若有则进行删除后并输出二叉树，若没有则给出不存在要删除的关键字的提醒。

（3）平衡二叉树的显示采用中序遍历的方法输出，还可以根据输出数据是否有序验证对平衡二叉树的操作是否正确。

设计说明

（一）ADT

ADTBalancedBinaryTree{

数据对象D：

D是具有相同特性的数据元素的集合。

各个数据元素均含有类型相同，可唯一标志的数据元素的关键字。

数据关系R：

数据元素同属一个集合。

基本操作P：

voidR_Rotate（BSTree&p）;

初始条件：

二叉树存在，且关键字插入到以*p为根的二叉树的左子树的左孩子上；

操作结果：

对以*p为根的二叉排序树作右旋处理

voidL_Rotate（BSTree&p）;

初始条件：

二叉树存在，且关键字插入到以*p为根的二叉树的右子树的右孩子上；

操作结果：

对以*p为根的二叉排序树作左旋处理

voidLeftBalance（BSTree&T）;

初始条件：

二叉树存在，且关键字插入到T所指节点为根的二叉树的左子树的右孩子上；

操作结果：

对以指针T所指结点为根的二叉树作左平衡旋转处理

voidRightBalance（BSTree&T）;

初始条件：

二叉树存在，且关键字插入到T所指节点为根的二叉树的右子树的左孩子上；

操作结果：

对以指针T所指结点为根的二叉树作右平衡旋转处理

boolInsertAVL（BSTree&T,inte,bool&taller）;

初始条件：

T存在，且e与二叉树的原有关键字不同；

操作结果：

插入结点e平且平衡化；

boolSearchBST（BSTree&T,intkey）;

初始条件：

T存在且元素key与某关键字相同；

操作结果：

查找元素key是否在树Ｔ中

voidPrintBST（BSTreeT）;

初始条件：

T存在

操作结果：

按中序遍历输出二叉树的元素

voidCreatBST（BSTree&T）;

初始条件：

T为空

操作结果：

创建平衡二叉树,（注意:

以输入-1为二叉树建立的结束）

voidLeftBalance_div（BSTree&p,int&shorter）;

初始条件：

T存在

操作结果：

删除结点时左平衡旋转处理

voidRightBalance_div（BSTree&p,int&shorter）;

初始条件：

T存在

操作结果：

删除结点时右平衡旋转处理

voidDelete（BSTreeq,BSTree&r,int&shorter）;

初始条件：

T存在且节点删除成功

操作结果：

删除结点

intDeleteAVL（BSTree&p,intx,int&shorter）;

初始条件：

操作结果：

平衡二叉树的删除操作

}ADTBalancedBinaryTree

（二）算法思想

1、查找

在根指针T所指二叉排序树中递归地查找某关键字等于key的数据元素，若查找成功，则返回指向该数据元素结点的指针,否则返回空指针。

如果树T为空，则查找不成功，返回空指针；当树T非空时，如果根指针T所指数据元素的关键字等于key，则查找成功，返回根指针T，否则在左子树中继续查找，若还未找到，则继续在右子树中进行查找，直到找到该数据元素或树T为空为止。

//查找元素key是否在树Ｔ中

boolSearchBST（BSTree&T,intkey）

{

if（!

T）returnfalse;

elseif（EQ（key,T->data））returntrue;

elseif（LT（key,T->data））returnSearchBST（T->lchild,key）;

elsereturnSearchBST（T->rchild,key）;

}

2、插入

（一）若T为空树，则插入一个数据元素为e的新节点作为T的根节点，树长高，树的深度增加1。

（二）若待插入的数据元素e与T的根节点的关键字相同，则不进行插入。

（三）若待插入的数据元素e小于根节点的关键字，且在T的左子树上不存在与e相等的数据元素，那么将e插入到T的左子树上。

下面就插入到左子树之后，就不同的情况进行处理：

①若之前T的根节点的平衡因子为-1，将根节点的平衡因子变为0，T的深度不变；

②若之前T的根节点的平衡因子为0，就将根节点的平衡因子变为1，T的深度增加；

③若之前的T的根节点的平衡因子为1，那么当其左子树的根节点的平衡因子为1的时候，需要进行单向右旋处理，并且在右旋处理之后，将根节点和其右子树根节点的平衡因子改为0，树的深度不变；当其左子树的根节点的平衡因子为-1的时候，要进行先左后右的双向旋转平衡，并在旋转之后，修改根节点和其左右子树的根节点的平衡因子，树的深度不变。

（四）若待插入的数据元素e大于根节点的关键字，且在T的右子树上不存在与e相等的数据元素，那么将e插入到T的右子树上。

下面就插入到右子树之后，就不同的情况进行处理：

①若之前T的根节点的平衡因子为1，将根节点的平衡因子变为0，T的深度不变；

②若之前T的根节点的平衡因子为0，就将根节点的平衡因子变为1，T的深度增加；

③若之前的T的根节点的平衡因子为-1，那么当其右子树的根节点的平衡因子为-1的时候，需要进行单向左旋处理，并且在左旋处理之后，将根节点和其左子树根节点的平衡因子改为0，树的深度不变；当其右子树的根节点的平衡因子为1的时候，要进行先右后左的双向旋转平衡，并在旋转之后，修改根节点和其左右子树的根节点的平衡因子，树的深度不变。

//插入结点e,若T中不存在和e相同关键字的结点，则插入一个数据元素为e的新结点，并返回1，否则返回0

boolInsertAVL（BSTree&T,inte,bool&taller）

{

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;

}

}

}

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;

}

}

}

}

return1;

}//InsertAVL

3、删除

元素的删除，有三种情况，分别是：

（1）被删除的结点是叶子；

（2）被删除的结点只有左子树或者只有右子树；

（3）被删除的结点既有左子树，也有右子树。

具体实现如下：

intDeleteAVL（BSTree&p,intx,int&shorter）

{

intk;

BSTreeq;

if（p==NULL）

{

printf（"不存在要删除的关键字!

!

\n"）;

return0;

}

elseif（xdata）//在p的左子树中进行删除

{

k=DeleteAVL（p->lchild,x,shorter）;

if（shorter==1）

LeftBalance_div（p,shorter）;

returnk;

}

elseif（x>p->data）//在p的右子树中进行删除

{

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;

}

}

（三）数据结构

本实验中平衡二叉树采用二叉链表的方式进行存储。

定义如下：

typedefstructBSTNode

{

intdata;

intbf;//结点的平衡因子

structBSTNode*lchild,*rchild;//左、右孩子指针

}BSTNode,*BSTree;

（四）程序结构与流程

本程序包括四个模块，分别为主函数、AVL的创建、AVL的查找函数、AVL的插入函数、AVL的删除函数。

流程图如下：

主函数

voidmain（）

AVL的创建

AVL的查找

AVL的插入

AVL的删除

主函数定义如下：

主函数主要是根据输入的数字选择要对平衡二叉树进行的操作，创建、查找、删除或者是插入。

voidmain（）

{

intinput,search;

booltaller=false;

intshorter=0;

BSTreeT,T1,T2;

T=（BSTree）malloc（sizeof（BSTNode））;

T=T1=T2=NULL;

while

（1）

{

printf（"1.创建\t2.查找\t3.插入\t4.删除\t5.退出*\n"）;

printf（"请输入您所需的操作功能:

\t"）;

scanf（"%d",&input）;

getchar（）;

switch（input）

{

case1:

CreatBST（T）;break;

case2:

printf（"请输入你要查找的关键字"）;

scanf（"%d",&search）;getchar（）;

if（SearchBST（T,search））printf（"该二叉树中存在关键字%d，查找成功!

\n",search）;

elseprintf（"查找失败!

\n"）;

break;

case3:

printf（"请输入你要插入的关键字"）;

scanf（"%d",&search）;getchar（）;

InsertAVL（T,search,taller）;

PrintBST（T）;break;

case4:

printf（"请输入你要删除的关键字"）;

scanf（"%d",&search）;getchar（）;

DeleteAVL（T,search,shorter）;

PrintBST（T）;break;

case5:

break;

default:

printf（"输入错误，请重新选择。

"）;break;

}

printf（"\t\t按任意键继续..."）;getchar（）;

}

}

运行平台及开发工具

该程序在WindowsXP/07上运行良好，使用MicrosoftVisualC++6.0开发。

I/O格式

输入：

该程序要求输入数据为整型数据，并以-1作为输入数据的结束标志，创建过程中若输入相同的数据只会生成一个关键字并给出输入数据相同的提示。

输出：

该程序对于对平衡二叉树的输出采用中序遍历的方法。

因为中序遍历平衡二叉树的得到的结果肯定为有序的，所以可以据此判断对于平衡二叉树操作的正确性。

测试数据：

1、创建

输入数据：

34、45、12、22、34、56、76、11、-45、23、-1；进行平衡二叉树的创建，运行结果如下图：

2、查找

①查找在原有二叉树上已存在的关键字：

【查找23】运行结果：

②查找在原有二叉树上不存在的数据：

【查找24】运行结果：

3、插入

在1的基础上进行插入，分两种情况：

①插入与原二叉树关键字不重复的数据：

【插入99】运行结果如下：

②插入已存在原二叉树中的数据：

【插入22】运行结果如下：

4、删除

①删除在原有平衡二叉树上已存在的关键字：

【删除22】运行结果如下：

②删除在原有平衡二叉树上不存在的数据：

【删除98】运行结果如下：

算法复杂度分析

在平衡二叉树上进行查找的过程和二叉排序树相同，因此，在查找的过程中与给定值进行比较的关键字个数不会超过数的深度。

因此平衡二叉树查找的时间复杂度主要由树的深度决定。

我们首先分析深度为h的平衡树所具有的最少结点数。

假设以N（h）表示深度为h的平衡树含有的最少结点数，显然，N（0）=0，N

（1）=1，N

（2）=2，并且N（h）=N（h-1）+N（h-2），在通过归纳法可以求出这个N（h），反之，在知道n的情况我们也可以推导出h的最大值，所以最后可以得到在平衡二叉树上查找的时间复杂度是T（n）=O（㏒2n）。

同样的插入和删除的时间复杂度也为O（㏒2n）。

源代码

#include

#include

#include

#defineEQ（a,b）（（a）==（b））

#defineLT（a,b）（（a）<（b））

#defineLQ（a,b）（（a）>（b））

#defineLH+1//左高

#defineEH0//等高

#defineRH-1//右高

#defineNULL0

typedefstructBSTNode

{

intdata;

intbf;//结点的平衡因子

structBSTNode*lchild,*rchild;//左、右孩子指针

}BSTNode,*BSTree;

voidR_Rotate（BSTree&p）;//对以*p为根的二叉排序树作右旋处理

voidL_Rotate（BSTree&p）;//对以*p为根的二叉排序树作左旋处理

voidLeftBalance（BSTree&T）;//对以指针T所指结点为根的二叉树作左平衡旋转处理

voidRightBalance（BSTree&T）;//对以指针T所指结点为根的二叉树作右平衡旋转处理

boolInsertAVL（BSTree&T,inte,bool&taller）;//插入结点e

boolSearchBST（BSTree&T,intkey）;//查找元素key是否在树Ｔ中

voidPrintBST（BSTreeT）;//按中序遍历输出二叉树的元素

voidCreatBST（BSTree&T）;//创建平衡二叉树,（注意:

以输入-1为二叉树建立的结束）

voidLeftBalance_div（BSTree&p,int&shorter）;//删除结点时左平衡旋转处理

voidRightBalance_div（BSTree&p,int&shorter）;//删除结点时右平衡旋转处理

voidDelete（BSTreeq,BSTree&r,int&shorter）;//删除结点

intDeleteAVL（BSTree&p,intx,int&shorter）;//平衡二叉树的删除操作

voidmain（）

{

intinput,search;

booltaller=false;

intshorter=0;

BSTreeT,T1,T2;

T=（BSTree）malloc（sizeof（BSTNode））;

T=T1=T2=NULL;

while

（1）

{

printf（"1.创建\t2.查找\t3.插入\t4.删除\t5.退出*\n"）;

printf（"请输入您所需的操作功能:

\t"）;

scanf（"%d",&input）;

getchar（）;

switch（input）

{

case1:

CreatBST（T）;break;

case2:

printf（"请输入你要查找的关键字"）;

scanf（"%d",&search）;getchar（）;

if（SearchBST（T,search））printf（"该二叉树中存在关键字%d，查找成功!

\n",search）;

elseprintf（"查找失败!

\n"）;

break;

case3:

printf（"请输入你要插入的关键字"）;

scanf（"%d",&search）;getchar（）;

InsertAVL（T,search,taller）;

PrintBST（T）;break;

case4:

printf（"请输入你要删除的关键字"）;

scanf（"%d",&search）;getchar（）;

DeleteAVL（T,search,shorter）;

PrintBST（T）;break;

case5:

break;

default:

printf（"输入错误，请重新选择。

"）;break;

}

printf（"\t\t按任意键继续..."）;getchar（）;

}

}

//对以*p为根的二叉排序树作右旋处理,LL型平衡旋转法

voidR_Rotate（BSTree&p）

{

BSTreelc;

lc=p->lchild;//lc指向的*p左子树根结点

p->lchild=lc->rchild;//lc的右子树挂接为*p的左子树

lc->rchild=p;

p=lc;//p指向新的结点

}

//对以*p为根的二叉排序树作左旋处理，RR型平衡旋转法

voidL_Rotate（BSTree&p）

{

BSTreerc;

rc=p->rchild;//rc指向的*p右子树根结点

p->rchild=rc->lchild;//rc的左子树挂接为*p的右子树

rc->lchild=p;

p=rc;//p指向新的结点

}

//对以指针T所指结点为根的二叉树作左平衡旋转处理，LR型平衡旋转法

voidLeftBalance（BSTree&T）

{

BSTreelc,rd;

lc=T->lchild;//lc指向*T的左子树根结点

switch（lc->bf）//检查*T的左子树的平衡度，并作相应平衡处理

{

caseLH:

//新结点插入在*T的左孩子的左子树上，要作单右旋处理

T->bf=lc->bf=EH;

R_Rotate（T）;break;

caseRH:

//新结点插入在*T的左孩子的右子树上，要作双旋处理

rd=lc->rchild;//rd指向*T的左孩子的右子树根

switch（rd->bf）//修改*T及其左孩子的平衡因子

{

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）;//对*T的左子树作左旋平衡处理

R_Rotate（T）;//对*T作右旋平衡处理

}

}

//对以指针T所指结点为根的二叉树作右平衡旋转处理，RL型平衡旋转法

voidRightBalance（BSTree&T）

{

BSTreerc,ld;

rc=T->rchild;//rc指向*