【修改】C实现平衡二叉树---AVL

最新推荐文章于 2024-04-06 15:06:05 发布
原创 最新推荐文章于 2024-04-06 15:06:05 发布 · 570 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c #null #struct #include

本文介绍了一种使用C语言实现的AVL平衡二叉树，包括插入、查找、中序遍历、先序遍历、删除、平衡旋转等关键操作。详细解释了如何在插入元素时维护树的平衡，以及删除节点后的平衡处理方法。 
/************************************************************************/  
/*                    C实现平衡二叉树---AVL                                                */  
/************************************************************************/  
#include <stdio.h>  
#include <stdlib.h>  
#define LH (+1)     /*左高*/
#define EH  0       /*等高*/
#define RH (-1)     /*右高*/
#define TRUE 1
#define FALSE 0
typedef int ElemType;  
typedef struct BiTNode                /*结点结构*/
{  
    ElemType data;                    /*结点数据*/
    int bf;                           /*平衡因子*/
    struct BiTNode *lchild,*rchild;   /*左右孩子指针*/
}BiTNode,*BiTree;  

/***********************************************************************
对以p为根的二叉树作右旋操作，处理之后
p指向新的根结点，即旋转处理之前的左子树的根结点
************************************************************************/
void R_Rotate(BiTree* p)  
{  
    BiTree lc = (*p)->lchild;  
    (*p)->lchild = lc->rchild;  
    lc->rchild = *p;  
    *p = lc;  
}  

/***********************************************************************
对以p为根的二叉树作左旋操作，处理之后
p指向新的根结点，即旋转处理之前的左子树的根结点
************************************************************************/
void L_Rotate(BiTree* p)  
{  
    BiTree rc = (*p)->rchild;  
    (*p)->rchild = rc->lchild;  
    rc->lchild = *p;  
    *p = rc;  
}  

/***********************************************************************
对以指针T所指结点为根的二叉树作左平衡旋转处理
本算法结束时，指针T指向新的根结点
************************************************************************/
void LeftBalance(BiTree* T)  
{  
    BiTree 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作右旋平衡处理*/
		break;	
    }  
}  


/***********************************************************************
  对以指针T所指结点为根的二叉树作右平衡旋转处理
  本算法结束时，指针T指向新的根结点
 ************************************************************************/
void RightBalance(BiTree* T)  
{  
    BiTree lc,rd;  
    lc= (*T)->rchild;   /*lc指向T的右子树根结点*/
    switch (lc->bf)  
    {  
        /*检查T的右子树的平衡度，并作相应平衡处理*/
        case RH:   /*新插入的结点在T的右孩子的右子树上，要作单左旋处理*/
			{
				(*T)->bf = lc->bf = EH;  
				L_Rotate(T);  
				break;	
			}
		
        case LH: /*新插入的结点在T的右孩子的左子树上，要作双旋处理*/
			{
				rd = lc->lchild;   /*rd指向T的右孩子的左子树的根*/
				switch(rd->bf)	    /*修改T极其右孩子的平衡因子*/
				{  
				    case LH:  
						{
							(*T)->bf = EH;	
							lc->bf = RH;  
							break;	
						}
				    case EH: 
						{
							(*T)->bf = lc->bf = EH;  
							break;	
						}
				    case RH: 
						{
							(*T)->bf = EH;	
							lc->bf = LH;  
							break;	
						}
				}  
			}
    rd->bf = EH;  
    R_Rotate(&(*T)->rchild);   /*对T的右子树作右旋平衡处理*/
    L_Rotate(T);               /*对T作左旋平衡处理*/
    break;  
    }  
}  

/***********************************************************************
若在平衡的二叉排序树T中不存在和e有相同关键字的结点，
则插入一个数据元素为e的新结点并返回1，否则返回0 。
若因插入而使二叉排序树失去平衡，则作平衡旋转处理，
变量taller反映T长高与否。
 ************************************************************************/
int InsertAVL(BiTree* T,ElemType e,int* taller)  
{  
    if ((*T)==NULL)  
    {    /*插入新结点，树长高，置taller为TRUE*/
        *T=(BiTree)malloc(sizeof(BiTNode));  
        (*T)->bf = EH;  
        (*T)->data = e;  
        (*T)->lchild = NULL;  
        (*T)->rchild = NULL;  
		*taller = TRUE;
    }  
    else if (e == (*T)->data)  
    {    /*树中已存在和e有相同关键字的结点则不再插入*/
        *taller = FALSE;  
        return FALSE;  
    }  
    else if (e < (*T)->data)  
    {    /*应继续在T的左子树中进行搜索*/
        if(!InsertAVL(&(*T)->lchild,e,taller))  /*未插入*/
        	{
                return FALSE;  
        	}
        if(*taller)   /*已插入到T的左子树中且左子树长高*/
        {  
            switch ((*T)->bf)   /*检查T的平衡度*/
            {  
                case LH:   /*原本左子树比右子树高，需要作左平衡处理*/
				    {
						LeftBalance(T);  
						*taller = FALSE;  
						break;	
					}
                case  EH:  /*原本左右子树等高，现因左子树长高而树长高*/
					{
						(*T)->bf = LH;	
						*taller = TRUE;  
						break;	
					}
                case RH:  /*原本右子树比左子树高，现左右子树等高*/
					{
						(*T)->bf = EH;	
						*taller = FALSE;  
						break;	
					}
            }  
        }  
    }  
    else  
    {   /*应继续在T的右子树中进行搜索*/
        if(!InsertAVL(&(*T)->rchild,e,taller))  /*未插入*/
        	{
                return 0;  
        	}
        if (*taller)   /*已插入到T的右子树中且右子树长高*/
        {  
            switch ((*T)->bf)   /*检查T的平衡度*/
            {  
                case LH:   /*原本左子树比右子树高，现左右子树等高*/
					{
						(*T)->bf = EH;	
						*taller = FALSE;  
						break;	
					}
                case EH:   /*原本左右子树等高，现因右子树长高而树长高*/
					{
						(*T)->bf = RH;	
						*taller = TRUE;  
						break;	
					}
                case  RH:  /*原本右子树比左子树高，需要作右平衡处理*/
					{
						RightBalance(T);  
						*taller = FALSE;  
						break;	
					}
            }  
        }  
    }  
    return 1;  
}  

  
/***********************************************************************
在平衡二叉树root中查找元素e，若存在则pos指向该节点
并返回TRUE，否则返回FALSE。
 ************************************************************************/
int FindNode(BiTree root,ElemType e,BiTree* pos)  
{  
    BiTree pt = root;  
    (*pos) = NULL;  
    while(pt)  
    {  
        if (pt->data == e)   /*找到节点，pos指向该节点并返回true */ 
        {  
            (*pos) = pt;  
            return TRUE;  
        }  
        else 
        {
			if (pt->data > e)  
            {  
                pt = pt->lchild;  
            }  
            else 
            {
				pt = pt->rchild;  
            }
        }
    }  
    return FALSE;  
}  

/***********************************************************************
在平衡二叉树中搜索关键字
 ************************************************************************/
void Find(BiTree root)
{
    BiTree pos=NULL;  
    int num;
    printf("Input the num to find:\n");
	scanf(" %d",&num);
    if(FindNode(root,num,&pos))
    {
        printf("\n%d is found\n",pos->data);  
    }
    else  
    {
        printf("\nNot find this Node\n");  
    }
}
/***********************************************************************
中根遍历平衡二叉树root，并输出结点
 ************************************************************************/
void InorderTra(BiTree root)  
{  
    if(root->lchild) 
    {
        InorderTra(root->lchild);  
    }
    printf("%d ",root->data);  
    if(root->rchild)  
    {
        InorderTra(root->rchild);  
    }
}   

/***********************************************************************
先根遍历平衡二叉树root，并输出结点(带空结点)
************************************************************************/
void PreorderTra(BiTree root)
{
    if(root == NULL)
    {
        printf("^ ");
        return ;
    }
	else
	{
	    printf("%d ",root->data);
		PreorderTra(root->lchild);
		PreorderTra(root->rchild);
	}
}


/***********************************************************************
在删除结点时进行左平衡处理
************************************************************************/
void LeftProcess1(BiTree *p,int *taller)	
{         
    BiTree p1,p2;
	if ((*p)->bf==1)
	{           
	    (*p)->bf=0;   
		*taller=1;  
	}
	else 
	{
	    if ((*p)->bf==0)
	    {         
	        (*p)->bf=-1;   
		    *taller=0;   
      	}
	    else		/*p->bf=-1*/
	    {
	    	p1=(*p)->rchild;
	    	if (p1->bf==0)			/*需作RR调整*/
			{    
			    (*p)->rchild=p1->lchild;
				p1->lchild=(*p);
				p1->bf=1;
				(*p)->bf=-1;
				(*p)=p1;
				*taller=0;
			}
			else 
			{
		    	if (p1->bf==-1)	             /*需作RR调整*/
		    	{
		    		(*p)->rchild=p1->lchild;
		    		p1->lchild=(*p);
				    (*p)->bf=p1->bf=0;
	    			(*p)=p1;
		  		  	*taller=1;
	    		}
	 			else					/*需作RL调整*/
				{
					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;
					*taller=1;
				}
			}
		}
	}
}


/***********************************************************************
在删除结点时进行右平衡处理
************************************************************************/
void RightProcess1(BiTree *p,int *taller)
{
	BiTree p1,p2;
	if ((*p)->bf==-1)
	{    
	    (*p)->bf=0;  
		*taller=-1;   
	}
	else 
	{
	    if ((*p)->bf==0)
	    {    
	        (*p)->bf=1;  
	    	*taller=0;   
	    }
	    else		/*(*p)->bf=1*/
	    {
		    p1=(*p)->lchild;
		    if (p1->bf==0)			/*需作LL调整*/
	    	{    
	    	    (*p)->lchild=p1->rchild;    
				p1->rchild=(*p);
		        p1->bf=-1;
				(*p)->bf=1;    
				(*p)=p1;       
				*taller=0;   
				}
		    else 
	    	{
		        if (p1->bf==1)		/*需作LL调整*/
	            {      
    	            (*p)->lchild=p1->rchild;   
	        		p1->rchild=(*p);
		            (*p)->bf=p1->bf=0;   
	        	    (*p)=p1;        
    	    		*taller=1;     
	        	}
		        else					/*需作LR调整*/
		        {    
		            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;      
	    		    *taller=1;  
	    	    }    
		    }
	    }
	}
}


/****************************************************************************
由DeleteAVL()调用,用于处理被删结点左右子树均不空的情况
*****************************************************************************/
void Delete2(BiTree q,BiTree *r,int *taller)  
{
	if ((*r)->rchild==NULL)
	{
		q->data=(*r)->data;
		q=*r;
		(*r)=(*r)->lchild;
		free(q);
		*taller=1;
	}
	else
	{
		Delete2(q,&((*r)->rchild),taller);
		if (*taller==1) 
		{
			RightProcess1(r,taller);
		}
	}
}

/****************************************************************************
在AVL树p中删除关键字为x的结点
*****************************************************************************/
int DeleteAVL(BiTree *p,ElemType x,int *taller)
{
	int k;
	BiTree q;
	if ((*p)==NULL) 
	{
		return 0;
	}
	if (x < (*p)->data)
	{            
	    k=DeleteAVL(&((*p)->lchild),x,taller);
		if (*taller==1) 
		{
			LeftProcess1(p,taller);
		}
		return k;     
	}
	else
	{
		if (x > (*p)->data)
		{		    
			k=DeleteAVL(&((*p)->rchild),x,taller);
			if (*taller==1) 
			{
				RightProcess1(p,taller);  
			}
			return k;	   
		}
		else			/*找到了关键字为x的结点,由p指向它*/
		{				
			q=(*p);
			if ((*p)->rchild==NULL)		/*被删结点右子树为空*/
			{		
				(*p)=(*p)->lchild;	  
				free(q);	
				*taller=1;	
			}
			else 
			{
				if ((*p)->lchild==NULL)	/*被删结点左子树为空*/
				{	  
					(*p)=(*p)->rchild;	 
					free(q);	 
					*taller=1;	 
				}
			    else					   /*被删结点左右子树均不空*/
			    {	
					Delete2(q,&(q->lchild),taller);
					if (*taller==1) 
					{
						LeftProcess1(&q,taller);    
					}
					(*p)=q;   
				}
			}
			return 1;
		}	
	}
}



int main()  
{  
    int i;
	int nArr[] = {1,23,45,43,38,95,23,42,55};  
    BiTree root=NULL;//,pos=NULL;  
    int taller;  
    for (i=0;i<9;i++)  
    {  
        InsertAVL(&root,nArr[i],&taller);  
    }  

	while(1)
	{
  		printf("1.InorderTra\n");
		printf("2.PreorderTra\n");
		printf("3.Insert\n");
		printf("4.Delete:\n");
		printf("5.Find:\n");
	    scanf(" %d",&i);
		switch(i)
			{
			    case 1:
					{
						printf("InorderTra:\n");
						InorderTra(root); 
						printf("\n");
						break;
					}
			    case 2:
					{
						printf("PreorderTra:\n");
						PreorderTra(root);
						printf("\n");
						break;
					}
			    case 3:
					{
						printf("Insert:\n");
						scanf(" %d",&i);
						InsertAVL(&root,i,&taller);  
						break;
					}
			    case 4:
					{
						printf("Delete:\n");
						scanf(" %d",&i);
						DeleteAVL(&root,i,&taller);
						break;
					}
			    case 5:
					{
						Find(root);
						break;
					}
				default:
					{
						break;
					}
			}
	}
    return 0;  
}

Static-AJ
关注
数据结构之---C语言实现平衡二叉树（AVL树）
杨鑫newlife的专栏
09-02 7734
数据结构之---C语言实现平衡二叉树（AVL树）
C语言实现平衡二叉树全过程
Yusamm的博客
04-23 1654
Root of AVL Tree An AVL tree is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than on...
C语言平衡二叉树csdn,平衡二叉树介绍 C语言实现
weixin_42299346的博客
05-20 138
网上看了一些平衡二叉树的说明和实现，自己再实现一遍加深记忆typedef struct TAG_AVL_T{int data; // valueint factor；// 平衡因子int hight;//二叉树高度BT_NODE* left;//左BT_NODE* right;}BT_NODE;#define LH +1//代表节点拥左子树#define EH 0//代表节点同时(不)拥有左右子树...
讲解平衡二叉树的实现（C语言）
最新发布
weixin_62756978的博客
04-06 2021
讲解如何实现平衡二叉树的构造、增加节点、删除节点等操作。
平衡二叉树 C语言代码实现
李肖遥的专栏
09-20 1296
关注、星标公众号，直达精彩内容来源： https://www.cnblogs.com/NoneID整理：李肖遥1. 什么是平衡二叉树平衡二叉树，我们也称【二叉平衡搜索树/AVL】,树中任何节点的两个子树的高度最大差别为1，巴拉巴拉。。。(https://baike.baidu.com/item/AVL树/10986648?fr=aladdin)但是有个注意的点: 平衡二叉树的前提是 二叉排...
C语言实现平衡二叉树
qq_43148788的博客
03-03 1344
C语言实现平衡二叉树
平衡二叉树 c/c++实现
左眼皮跳跳
03-27 2284
一直觉得平衡二叉树是非常麻烦的数据结构，关于树的旋转非常麻烦，最近特殊情况学了一下，参考了网上的代码，写这个让我对指针有了更加深入的了解，感觉收益匪浅，恶心的地方就是，当我程序无法运行出我的期望结果时，我debug就苦逼了，真的比较苦逼，一点小的注释在代码中，目前就自己出了几组样例测试了一下，感觉没什么大问题，比较低级，勿喷，如果发现代码中的bug,欢迎留言告知 #include #in
基于C语言实现二叉树-堆-图（数据结构实验）【100012026】
04-25
在本实验中，我们关注的是二叉排序树（BST）和平衡二叉树（AVL树）。二叉排序树是一种自平衡的二叉搜索树，其特性是左子树上的所有节点值都小于根节点，右子树上的所有节点值都大于根节点。这使得插入、删除和查找...
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2979
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
C语言实现平衡二叉树的操作与测试
在C语言实现的“C语言平衡二叉树.zip”这一文件中，标题明确指出其核心内容为使用C语言实现平衡二叉树，结合描述“玩转二叉树”，可以推断该资源旨在帮助学习者深入掌握二叉树尤其是平衡二叉树的操作机制与编程实践...
平衡二叉树基本操作（AVL平衡二叉树）
manerzi的博客
11-13 958
平衡二叉树基本操作（AVL平衡二叉树）
平衡二叉树的C语言实现
weixin_40819228的博客
09-14 7430
   平衡二叉树的结构 //平衡二叉树相对于二叉排序树的数据结构增加了平衡因子和父亲节点 typedef struct T{ int data;//节点数据 int bal;//平衡因子 struct T *lchild,*rchild,*parent;//左孩子、右孩子、父亲节点 }*BiTree,LNode;  平衡二叉树的旋转操作        当某一节点的平...
AVL（自平衡二叉树）树的实现（C语言）
c_living的博客
07-23 5315
AVL树是可以在插入、删除节点之后进行自平衡的树，平衡的定义是结点的左子树和右子树的深度差不超过1，也就： | Deep（LeftChild） - Deep（RightChild）| &lt;= 1，整棵树的平衡也就是树的每个结点都是满足上述情况。那么下面我们要解决问题就是当树在插入数据和删除数据的时候，如果树不平衡了我们该怎么办。 上面就是我们在插入或者删除的时候可能导致的树的不平衡的所...
C语言实现AVL-平衡二叉树
silence2015的专栏
03-23 9991
前言在学习了二叉搜索树后，我们可以通过二叉搜索树实现结点有序存储。 我们在删除结点的时候，采用的是该结点右子树中最小结点代替他，探后再删除最小的那个结点，这种做法虽然保证了二叉树的有序性，但是久而久之使二叉树越来越不平衡，右边结点越来越少。像这样 或许在右子树中选择最小和左子树中选择最大轮换地使用可以稍微解决一下这种不平衡，但是在这里我们介绍一种AVL树来保证二叉查找树的平衡，AVL树得名于它的
K8s 很难么？带你从头到尾捋一遍，不信你学不会
热门推荐
民工哥的博客
02-23 1万+
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 4276
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
C语言实现平衡二叉树课程设计与演示
综上所述，这份文件中所涉及的知识点围绕数据结构课程设计中平衡二叉树的学习与实现展开，包括了平衡二叉树的定义、特性、C语言的编程实现、树的遍历算法以及如何输出和展示数据结构等。这些内容不仅涵盖了数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值