AVL算法

最新推荐文章于 2020-10-07 18:54:34 发布
最新推荐文章于 2020-10-07 18:54:34 发布
阅读量1.4k 收藏
点赞数
文章标签： 算法 search delete null div input
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bb2b2bbb/article/details/6585823
版权
  
#include<stdio.h>
#include<stdlib.h>
#define EH  0
#define LH  1
#define RH  -1
typedef struct Bitree
{
	int data;
	int bf;                                          //该根结点的平衡度
	struct Bitree * lchild,*rchild;
}Bitree,*BiNtree;
void R_Roate(BiNtree *t);                             //以*t为节点右旋转树  
void L_Roate(BiNtree *t);                             //以*t为节点左旋转树  
void LeftBalance(BiNtree *t);                         //左旋转以平衡该树
void ReftBalance(BiNtree *t);                         //右旋转以平衡该树
void inserttree(BiNtree *t,int number,int *taller);   //插入节点
void createtree(BiNtree *t);                          //创建平衡二叉树
int SearchBST(BiNtree t,int key,int count);           //查找元素key是否在树Ｔ中并返回查找次数
void LeftBalance_div(BiNtree *p,int *shorter);        //删除结点时左平衡旋转处理
void RightBalance_div(BiNtree *p,int *shorter);       //删除结点时右平衡旋转处理
void Delete(BiNtree q,BiNtree *r,int *shorter);       //删除结点
int DeleteAVL(BiNtree *p,int x,int *shorter);         //平衡二叉树的删除操作
void main()
{
	int input,search,m;
    //int taller=false;
	int count;
	int shorter=0;
	int taller=0;
    BiNtree T,T1,T2;
    //T=(BSTree)malloc(sizeof(BSTNode));
    T=T1=T2=NULL;
	while(1)
	{   
		count=1;
		system("cls"); 
		printf("             ******************************************\n");
		printf(" ╱◥██◣  *1.创建\t2.查找\t3.插入\t4.删除\t5.退出*\n");
		printf("｜田｜田田│ ******************************************\n");
		printf("╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬<平衡二叉树 制作V1.0>\n");
        printf("请输入您所需的操作功能:\t");
        scanf("%d",&input);getchar();   
		switch(input)
		{
		   case 1:
			   createtree(&T); break;
		   case 2:
			   printf("请输入你要查找的关键字");
               scanf("%d",&search); getchar();
               if(SearchBST(T,search,count))
			   {
				   count=SearchBST(T,search,count); 
				   printf("该二叉树中存在关键字%d，%d,查找成功!\n",search,count);
			   }
               else printf("查找失败!\n");
               break;
		   case 3:
               printf("请输入你要插入的关键字");
               scanf("%d",&search); getchar();
               inserttree(&T,search,&taller); m = 0;
			   //PrintBST(T,m);
			   break;
		   case 4:
			   printf("请输入你要删除的关键字");
			   scanf("%d",&search); getchar();
			   DeleteAVL(&T,search,&shorter);
			  // m=0; PrintBST(T,m); 
			   break;
		   case 5:
               printf("\t\tbyebye!\n");break;
		   default:printf("输入错误，请重新选择。");break;
		}
		if(input == 5) break;
		printf("\t\t按任意键继续..."); getchar();
	}
}
//以*t为节点右旋转树
void R_Roate(BiNtree *t)                              
{
	BiNtree temp;
	temp= (*t)->lchild;
	(*t)->lchild=temp->rchild;
	temp->rchild=*t;
	*t=temp;
}
 //以*t为节点左旋转树
void L_Roate(BiNtree *t)                            
{
	BiNtree temp;
	temp =(*t)->rchild;
	(*t)->rchild=temp->lchild;
	temp->lchild=*t;
	*t=temp;
}

//左旋转以平衡该树
void LeftBalance(BiNtree *t)
{
	BiNtree lc,rd;
	lc=(*t)->lchild;
	switch(lc->bf)
	{
	case LH:                          //新结点插入在*T的左孩子的左子树上，要作单右旋处理
        (*t)->bf = lc->bf = EH;
        R_Roate(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_Roate(&(*t)->lchild);    //对*T的左子树作左旋平衡处理
        R_Roate(t);                //对*T作右旋平衡处理
	}

}
//右旋转以平衡该树
void RightBalance(BiNtree *t)
{
    BiNtree rc,ld;
    rc = (*t)->rchild;         //rc指向*T的右子树根结点
    switch(rc->bf)          //检查*T的右子树的平衡度，并作相应平衡处理
    {
    case RH:                //新结点插入在*T的右孩子的右子树上，要作单左旋处理
        (*t)->bf = rc->bf =EH;
        L_Roate(t); break;
    case LH:                //新结点插入在*T的右孩子的左子树上，要作双旋处理
        ld = rc->lchild;    //ld指向*T的右孩子的左子树根
        switch(ld->bf)      //修改*T及其右孩子的平衡因子
        {
        case LH: (*t)->bf = EH; rc->bf = RH; break;
        case EH: (*t)->bf = rc->bf =EH; break;
        case RH: (*t)->bf = LH; rc->bf = EH; break;
        }
        ld->bf = EH;
        R_Roate(&(*t)->rchild);//对*T的右子树作左旋平衡处理
        L_Roate(t);        //对*T作左旋平衡处理
    }
}
//向树中插入节点
void inserttree(BiNtree *t,int number,int *taller) 
{
	if(*t==NULL)
	{
		*t=(BiNtree)malloc(sizeof(Bitree));
		(*t)->data=number;
		(*t)->lchild=(*t)->rchild=NULL;
		(*t)->bf=EH;
		*taller=1;
	}
	else
	{
		if(number<(*t)->data)
		{
			inserttree(&(*t)->lchild,number,taller);
		    if(*taller)
			   switch((*t)->bf)
				{
					case LH:                  //原本左子树比右子树高，需要作左平衡处理
						LeftBalance(t); 
						*taller = 0;
						break;
					case EH:                
						(*t)->bf = LH;        //原本左子树、右子等高，现因左子树增高而使树增高
						*taller = 1;
						break;
					case RH:                  //原本右子树比左子树高，现左、右子树等高
						(*t)->bf = EH; 
						*taller = 0;
						break;
				}//switch(T->bf)
		}
		if(number>(*t)->data)  //应继续在*T的右子树中进行搜索
		{
            inserttree(&(*t)->rchild,number,taller);
            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;
            }	//switch(T->bf)
		}
	}  
}
            
//创建平衡二叉树，（注意：以输入－１为二叉树建立的结束）
void createtree(BiNtree *t)
{
    int e,m;
    int taller=0;          //0表示树没有长高，1表示树长高了
    *t= NULL;
    printf("\n请输入关键字(以-1结束建立平衡二叉树):");
    scanf("%d",&e);getchar();
    while(e != -1)
    {
        inserttree(t,e,&taller);
        printf("\n请输入关键字(以-1结束建立平衡二叉树):");
        scanf("%d",&e);getchar();
		taller=0;
    }

}
//查找元素key是否在树Ｔ中并返回查找次数
int SearchBST(BiNtree t,int key,int count)
{
    if(!t) return -1;
    else if(key==t->data) return count;
    else if(key<t->data) return SearchBST(t->lchild,key,count+1);
    else return SearchBST(t->rchild,key,count+1);
}
//删除结点时左平衡旋转处理
void LeftBalance_div(BiNtree *p,int *shorter)
{
	BiNtree  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                             //p结点的右子树高
	{
		p1=(*p)->rchild;                //p1指向p的右子树
		if(p1->bf==0)                //p1结点左、右子树等高,删除结点后p的bf为-2,进行左旋处理，树高不变
		{
			L_Roate(p);
			p1->bf=1; (*p)->bf=-1; *shorter=0;
        }
		else if(p1->bf==-1)          //p1的右子树高，左旋处理后，树变矮
        {
			L_Roate(p);
            p1->bf=(*p)->bf=0; *shorter=1;
        }
		else                         //p1的左子树高,进行双旋处理(先右旋后左旋)，树变矮
        {
			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 RightBalance_div(BiNtree *p,int *shorter)
{
	BiNtree p1,p2;
	if((*p)->bf==RH)
	{ (*p)->bf=EH; *shorter=1; }
    else if((*p)->bf==EH)
	{ (*p)->bf=LH; *shorter=0; }
    else
    { 
		p1=(*p)->lchild;
        if(p1->bf==EH)
        {
			R_Roate(p);
            p1->bf=RH;
			(*p)->bf=LH;
			*shorter=0;
		}
        else if(p1->bf==LH)
        {
			R_Roate(p);
            p1->bf=(*p)->bf=EH;
			*shorter=1;
        }
        else
        {
            p2=p1->rchild;
            p1->rchild=p2->lchild;
			p2->lchild=p1; 
			(*p)->lchild=p2->rchild;
			p2->rchild=*p;
            if(p2->bf==EH)
            { (*p)->bf=EH; p1->bf=EH; }
            else if(p2->bf==LH)
            { (*p)->bf=RH; p1->bf=EH; }
            else 
            { (*p)->bf=EH; p1->bf=LH; }
            p2->bf=EH; 
			*p=p2; 
			*shorter=1;
		}
	}
}
//删除结点
void Delete(BiNtree q,BiNtree *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);
	}
}
//平衡二叉树的删除操作
int DeleteAVL(BiNtree *p,int x,int *shorter)
{
	int k;
    BiNtree q;
    if(p==NULL)  { printf("不存在要删除的关键字!!\n"); return 0;}
    else if(x<(*p)->data)//在p的左子树中进行删除
    { 
		k=DeleteAVL(&(*p)->lchild,x,shorter);
        if(*shorter==1)
			LeftBalance_div(p,shorter);
		return k;
	}
	else if(x>(*p)->data)//在p的右子树中进行删除
    {
		k=DeleteAVL(&(*p)->rchild,x,shorter);
		if(*shorter==1)
			RightBalance_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 1;
	}
}

a_1_2_ab
关注
平衡树——AVL算法
_int_me的博客
05-02 1184
有关AVL树的解析
Java 数据结构与算法之树(AVL)
java1527的博客
09-26 394
AVL树历史在计算机科学中，AVL 树以其两位苏联发明家Georgy Adelson-Velsky和 Evgenii Landis的名字命名，他们在 1962 年的论文“信息组织算法”中发表了它。它是一种自平衡二叉搜索树(BST)，这是发明的第一个这样的数据结构。
avl
chivalry
09-08 1140
http://www.cnblogs.com/heqile/archive/2011/11/28/2265713.html http://dongxicheng.org/structure/avl/ 看完了《数据结构与算法分析(C++描述)》的4.4节AVL树,做一个总结,整理一下自己实现删除算法的思路.(注:本文中图片均来自《数据结构与算法分析(C++描述)》)     A
AVL算法分析
u010921373的专栏
05-13 787
一、何为AVL平衡树？ 具有以下特点： 1.二叉查找树结构（左孩子结点 < 父结点 < 右孩子结点） 2.结点左右两边的高度差(平衡因子balance)为[-1,1] => balance = | Deep（LeftChild） - Deep（RightChild）| <= 1 3.失衡：balance > 1 ==> balance == 2 ==> 左平衡(Deep(LeftChild)-Deep(RightChild) == 2) balance &lt
AVL算法实现
仗贱走天涯
09-25 504
http://blog.csdn.net/programmingring/article/details/37969745
【算法学习】AVL平衡二叉搜索树原理及各项操作编程实现（C++）
热门推荐
计算机专业同学的充电站。
12-13 1万+
AVLTree即（Adelson-Velskii-Landis Tree），是加了额外条件的二叉搜索树。其平衡条件的建立是为了确保整棵树的深度为O(nLogn)。平衡条件是任何节点的左右子树的高度相差不超过1. 在下面的代码中，编程实现了AVL树的建立、查找、插入、删除、遍历等操作。采用C++类封装。 AVL树中比较复杂的操作时插入和删除操作。在这里对插入和删除操作进行讲解。
AVL算法插入删除算法
09-29
AVL算法，实现了正常的插入删除算法，代码运行正常，为算法导论上的一道题
avltree算法.rar_avl_avl tree
09-21
学习AVL树不仅能够理解其基本概念和操作，还能深入理解数据结构的设计和优化，这对于理解和编写高效的算法至关重要。在实际应用中，AVL树常用于数据库索引、编译器符号表管理等场景，其高效的数据访问性能对于提升...
AVL 算法分析
12-22
AVL树是一种自平衡二叉查找树（Balanced Binary Search Tree），由Georgy Adelson-Velsky和E.M. Landis在1962年提出，因此得名AVL树。这种数据结构的主要特点是其左右子树的高度差不超过1，从而确保了搜索、插入和...
基于双向堆栈的avl树双向迭代算法
最新发布
05-23
### 基于双向堆栈的AVL树双向迭代算法详解 #### 一、引言与背景 在现代计算机科学中，数据结构的设计对于优化算法性能至关重要。平衡二叉搜索树，尤其是AVL树，因其良好的查找性能和有序的数据存储方式而被广泛...
MIT气动计算软件AVL，带源码、使用说明、示例
03-25
MIT气动计算软件AVL，带源码、使用说明、示例
数据结构与算法简记：AVL树
LiuHe
08-10 3182
前面记录了二叉查找树，它在搜索方面的效率显而易见，可它也存在某种缺陷，假设我们连续插入较小或较大的数据，那么二叉查找树将会逐渐退变为一个线性结构，从而搜索就变为了线性查找，效率将会大打折扣。所以，我们需要一棵这样的树，它在插入新节点后，能够重新调整自己的结构，使左右恢复平衡。AVL树就符合这个条件。AVL树是最先发明的自平衡二叉查找树，其得名于它的发明者 G.M. Adelson-Velsky 和
算法：二叉平衡树（AVL树）
OceanStar的博客
10-07 7420
平衡二叉树定义 平衡二叉树 全称叫做 平衡二叉搜索（排序）树，简称 AVL树。英文：Balanced Binary Tree （BBT），注：二叉查找树(BST) AVL 什么意思？AVL 是大学教授 G.M. Adelson-Velsky 和 E.M. Landis 名称的缩写，他们提出的平衡二叉树的概念，为了纪念他们，将 平衡二叉树 称为 AVL树。 AVL树本质上是一颗二叉查找树，但是它又具有以下特点： 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1， 左右两个子树 也都是一棵平衡二叉树。
AVL树（算法导论）
-.-嘻嘻
09-03 849
#include #include using namespace std; struct node { node *left; node *right; node *parent; int data; int h; node() : left(nullptr), right(nullptr), parent(nullptr), data(0), h(0){} node(i
一步一步写平衡二叉树（AVL树）
weixin_30588907的博客
08-20 593
一步一步写平衡二叉树（AVL树） 作者：C小加 更新时间：2012-8-20 　　平衡二叉树（Balanced Binary Tree）是二叉查找树的一个进化体，也是第一个引入平衡概念的二叉树。1962年，G.M. Adelson-Velsky 和 E.M. Landis发明了这棵树，所以它又叫AVL树。平衡二叉树要求对于每一个节点来说，它的左右子树的高度之差不能超过1，如果插入或者删除一个节...
算法-AVL树的插入
tang_jin2015的专栏
02-26 1130
AVL树的插入 AVL树是一种平衡二叉树，虽然删除的复杂度。以及出现的情况比红黑树简单，但是要不断的回溯 本文对2的因子直接一步进行右旋，相应的是一步的左旋 AVL树的查找的确是比红黑树更快。但是平衡性要求相当的大。以至于若是分布不均的话进行的操作回比红黑树多 代码： template void AVL_Tree::AVL_TREE_INSERT(AVL_Tree*avlTree,T
AVL树算法介绍与总结
qq_37329281的博客
02-22 507
  在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文 "An algorithm fo...
经典查找算法 -AVL树
sjyttkl的专栏
04-16 998
1，介绍---->来自百度 平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。 最小二叉平衡树的节点的公式如下 F(n)=F(n-1)+F(n-2)+1 这个类似于
查找算法（4）平衡二叉树（AVL）
kaka
06-23 321
一 .基本思想     1.   AVL树是高度平衡的二叉树，满足左子树树上所有节点的值均小于根节点的值，右子树上所有节点的值均大于根节点的值，它的左右子树也分别为二叉搜索树    2.AVL树性质        （1）左子树和右子树高度之差绝对值不超过1        （2）树中每个左子树和右子树都是AVL树        （3）任何一个节点的平衡因子（BF）是 -1，0-1之一二.AVL树的调...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值