AVL树的插入删除查找算法实现和分析-1(平衡因子法）

最新推荐文章于 2020-05-02 19:43:12 发布
最新推荐文章于 2020-05-02 19:43:12 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： AVL树 算法
      最近在学习数据结构，正在学习的有平衡二叉树（AVL树）和红黑树，红黑树是平衡二叉树的变种，因此在学习红黑树之前最好先学习AVL树，就目前使用度而言，红黑树在各个领域使用的更加广泛，因为红黑树相对AVL树来说，是一种不严格的旋转策略，而AVL树是相对严格的平衡策略（一旦发现不平衡了，立即旋转），因此对大数据而言，AVL树的查找效率高，而插入和删除相对慢一些，而红黑树的插入和删除效率要高一些，因此要根据不同应用场景选择。

AVL树的最大高度是1.44 * log(N+2) - 1.328，红黑树的最大高度是2.00* log(N+1)。

这篇文章转载自：http://blog.csdn.net/ljianhui/article/details/9137177 

感谢这位作者，不过对于作者提出的导致复杂的原因中说明使用了二级指针使程序复杂，我个人的观点认为：对于程序而言，最重要的是性能和稳定，的确二级指针很容易出错，但是为了方便而使返回是指针的话，如果程序在某个地方出现了错误，返回了NULL指针，那么这个程序的这部分数据结构，可能就有内存泄露或段错误之类的未知错误，很容易导致程序死去，这样的话，诚然可以很快（也许）找到错误点，但如果数据结构是用于服务器开发， 总不可能让服务器在运行时候死掉吧，所以我个人还是觉得性能和稳定最重要，在用二级指针小心一点就是。（只是个人观点）


在最后我将附上我自己写的代码，我没有写注释，因为和原作者差不多的。在下一个AVL实现（高度法）我将注明我和作者不一样的地方，同时会注释的，希望大家去支持原作者。如果有版权的问题，可以找我。


至于什么是AVL树和AVL树的一些概念问题在这里就不多说了，下面是我写的代码，里面的注释非常详细地说明了实现的思想和方法。


因为在操作时真正需要的是子树高度的差，所以这里采用-1，0，1来表示左子树和右子树的高度差，而没有使用记录树的高度的方法。

代码如下：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. #define FALSE 0  
  2. #define TRUE 1  
  3. #define LH 1  
  4. #define EH 0  
  5. #define RH -1  
  6.   
  7. typedef struct AVLNode  
  8. {  
  9.     DataType cData;  
  10.     int nBf;        //结点的平衡因子，-1表示右子树的深度比左子树高1  
  11.                     //0表示左子树与右子树深度相等  
  12.                     //1表示左子树的深度比右子树高1  
  13.     struct AVLNode *LChild;  
  14.     struct AVLNode *RChild;  
  15. }AVLNode,*AVLTree;  
  16.   
  17. typedef int BOOL;  

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. void R_Rotate(AVLTree *pAT)  
  2. {  
  3.     //对以*pAT为根的二叉树作右旋转处理，处理之后pAT指向新的树根结点  
  4.     //即旋转处理之前的左子树的根结点  
  5.     AVLTree lc = (*pAT)->LChild;  
  6.     (*pAT)->LChild = lc->RChild;  
  7.     lc->RChild = *pAT;  
  8.     *pAT = lc;  
  9. }  
  10.   
  11. void L_Rotate(AVLTree *pAT)  
  12. {  
  13.     //对以*pAT为根的二叉树作左旋转处理，处理之后pAT指向新的树根结点  
  14.     //即旋转处理之前的右子树的根结点  
  15.     AVLTree rc = (*pAT)->RChild;  
  16.     (*pAT)->RChild = rc->LChild;  
  17.     rc->LChild = *pAT;  
  18.     *pAT = rc;  
  19. }  
  20.   
  21. void LeftBalance(AVLTree *pAT)  
  22. {  
  23.     //对以指针pAT所指结点为根的二叉树作左平衡旋转处理，  
  24.     //本算法结束时指针pAT指向新的结点  
  25.     AVLTree lc = (*pAT)->LChild;    //lc指向*pAT的左子树根结点  
  26.     AVLTree rd = NULL;  
  27.     if(lc)  
  28.     switch(lc->nBf)     //检查*pAT的左子树的平衡度，并作相应平衡处理  
  29.     {  
  30.         case LH:    //新结点插入在*pAT的左孩子的左子树上，要作单右旋转处理  
  31.             (*pAT)->nBf = lc->nBf = EH;  
  32.             R_Rotate(pAT);  
  33.             break;  
  34.         case RH:    //新结点插入在*pAT的左孩子的右子树上，要作双旋转处理  
  35.             rd = lc->RChild;  
  36.             switch(rd->nBf) //修改*pAT及其左孩子的平衡因子  
  37.             {  
  38.                 case LH:  
  39.                     (*pAT)->nBf = RH;  
  40.                     lc->nBf = EH;  
  41.                     break;  
  42.                 case EH:  
  43.                     (*pAT)->nBf = lc->nBf = EH;  
  44.                     break;  
  45.                 case RH:  
  46.                     (*pAT)->nBf = EH;  
  47.                     lc->nBf = LH;  
  48.                     break;  
  49.                 default:;  
  50.             }  
  51.             rd->nBf = EH;  
  52.             L_Rotate(&(*pAT)->LChild);  //对*pAT的左子树作左平衡处理  
  53.             R_Rotate(pAT);      //对*pAT作右平衡处理  
  54.             break;  
  55.         default:;  
  56.     }  
  57. }  
  58.   
  59. void RightBalance(AVLTree *pAT)  
  60. {  
  61.     //对以指针pAT所指结点为根的二叉树作右平衡旋转处理，  
  62.     //本算法结束时指针pAT指向新的结点  
  63.     AVLTree rc = (*pAT)->RChild;  
  64.     AVLTree rd = NULL;  
  65.     if(rc)  
  66.     switch(rc->nBf)  
  67.     {  
  68.         case RH:  
  69.             (*pAT)->nBf = rc->nBf = EH;  
  70.             L_Rotate(pAT);  
  71.             break;  
  72.         case LH:  
  73.             rd = rc->LChild;  
  74.             switch(rd->nBf)  
  75.             {  
  76.                 case LH:  
  77.                     (*pAT)->nBf = EH;  
  78.                     rc->nBf = RH;  
  79.                     break;  
  80.                 case EH:  
  81.                     (*pAT)->nBf = rc->nBf = EH;  
  82.                     break;  
  83.                 case RH:  
  84.                     (*pAT)->nBf = LH;  
  85.                     rc->nBf = EH;  
  86.                     break;  
  87.             }  
  88.             rd->nBf = EH;  
  89.             R_Rotate(&(*pAT)->RChild);  
  90.             L_Rotate(pAT);  
  91.         default:;  
  92.     }  
  93. }  

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. BOOL InsertATNode(AVLTree *pAT, DataType c)  
  2. {  
  3.     //若在平衡的二叉树pAT中不存在和c相同的关键字结点，  
  4.     //则插入一个以c为数据元素的新结点，并返回1，否则返回0  
  5.     //若因插入而使二叉排序树失去平衡，则作平衡旋转处理  
  6.     static int taller = FALSE;  //反映pAT树是否长高  
  7.     if(!(*pAT))  
  8.     {  
  9.         //插入新结点，树长高，taller为TRUE;  
  10.         (*pAT) = (AVLTree)malloc(sizeof(AVLNode));  
  11.         (*pAT)->cData = c;  
  12.         (*pAT)->LChild = (*pAT)->RChild = NULL;  
  13.         (*pAT)->nBf = EH;  
  14.         taller = TRUE;  
  15.     }  
  16.     else  
  17.     {  
  18.         if((*pAT)->cData == c)  
  19.         {  
  20.             //树中已存在和e相同关键字的结点，不插入  
  21.             taller = FALSE;  
  22.             return 0;  
  23.         }  
  24.         if(c < (*pAT)->cData)  
  25.         {  
  26.             //应该在*pAT的左子树中进行搜索  
  27.             if(!InsertATNode(&(*pAT)->LChild, c))   //未插入  
  28.                 return 0;  
  29.             if(taller)  //已插入到树pAT并且左子树长高  
  30.             {  
  31.                 switch((*pAT)->nBf) //检查*pAT的平衡因子  
  32.                 {  
  33.                     case LH:    //原本左子树比右子树高，作左平衡处理  
  34.                         LeftBalance(pAT);  
  35.                         taller = FALSE;  
  36.                         break;  
  37.                     case EH:    //原本左右子树等高，现左子树比右子树高1  
  38.                         (*pAT)->nBf = LH;  
  39.                         taller = TRUE;  
  40.                         break;  
  41.                     case RH:    //原本右子树比左子树高，现左右子树等高  
  42.                         (*pAT)->nBf = EH;  
  43.                         taller = FALSE;  
  44.                         break;  
  45.                 }  
  46.             }  
  47.         }  
  48.         else  
  49.         {  
  50.             //应该在*pAT的右子树中进行搜索  
  51.             if(!InsertATNode(&(*pAT)->RChild, c))   //未插入  
  52.                 return 0;  
  53.             if(taller)  //已插入到树pAT并且右子树长高  
  54.             {  
  55.                 switch((*pAT)->nBf) //检查*pAT的平衡因子  
  56.                 {  
  57.                     case LH:    //原本左子树比右子树高，现左右子树等高  
  58.                         (*pAT)->nBf = EH;  
  59.                         taller = FALSE;  
  60.                         break;  
  61.                     case EH:    //原本左右子树等高，现右子树比左子树高1  
  62.                         (*pAT)->nBf = RH;  
  63.                         taller = TRUE;  
  64.                         break;  
  65.                     case RH:    //原本右子树比左子树高，作右平衡处理  
  66.                         RightBalance(pAT);  
  67.                         taller = FALSE;  
  68.                         break;  
  69.                 }  
  70.             }  
  71.         }  
  72.     }  
  73.     return 1;  
  74. }  

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. BOOL DeleteNode(AVLTree *pAT, DataType c)  
  2. {  
  3.     //若在平衡的二叉树pAT中存在和c相同的关键字结点，  
  4.     //则删除一个以c为数据元素的结点，并返回1，否则返回0  
  5.     //若因删除而使二叉排序树失去平衡，则作平衡旋转处理  
  6.     static int lower = FALSE;   //反映pAT树是否变矮  
  7.     if(!(*pAT))     //树为空或结点不存在返回0  
  8.         return 0;  
  9.     if(c == (*pAT)->cData)  
  10.     {  
  11.         //存在要删除的结点  
  12.         //查找用作替换的结点  
  13.         AVLTree Min = FindMin((*pAT)->RChild);  
  14.         if(Min != NULL) //存在右子树  
  15.         {  
  16.             //找到可以用作替换的点  
  17.             (*pAT)->cData = Min->cData;  
  18.             if(Min != (*pAT)->RChild)  
  19.             {  
  20.                 AVLTree Parent = GetParent((*pAT)->RChild, Min->cData);  
  21.                 Parent->LChild = Min->RChild;  
  22.             }  
  23.             else  
  24.             {  
  25.                 (*pAT)->RChild = Min->RChild;  
  26.             }  
  27.   
  28.             free(Min);  
  29.         }  
  30.         else //不存在右子树  
  31.         {  
  32.             //找不到删除的结点  
  33.             Min = *pAT;  
  34.             *pAT = (*pAT)->LChild;  
  35.             free(Min);  
  36.         }  
  37.         lower = TRUE;  
  38.     }  
  39.     else if(c < (*pAT)->cData)  
  40.     {  
  41.         //应该在*pAT的左子树中进行搜索  
  42.         if(!DeleteNode(&(*pAT)->LChild, c)) //未删除  
  43.             return 0;  
  44.   
  45.         if(lower)   //树变矮  
  46.         {  
  47.             switch((*pAT)->nBf)  
  48.             {  
  49.                 case LH:    //原本左子树比右子树高，现在等高  
  50.                     (*pAT)->nBf = EH;  
  51.                     lower = TRUE;  
  52.                     break;  
  53.                 case EH:    //原本左右子树等高，现右子树比左子树高1  
  54.                     (*pAT)->nBf = RH;  
  55.                     lower = FALSE;  
  56.                     break;  
  57.                 case RH:    //原本右子树比左子树高，则作右平衡处理  
  58.                     RightBalance(pAT);  
  59.                     lower = TRUE;  
  60.                     break;  
  61.             }  
  62.         }  
  63.     }  
  64.     else if(c > (*pAT)->cData)  
  65.     {  
  66.         //应该在*pAT的右子树中进行搜索  
  67.         if(!DeleteNode(&(*pAT)->RChild, c))  
  68.             return 0;  
  69.         if(lower)  
  70.         {  
  71.             switch((*pAT)->nBf)  
  72.             {  
  73.                 case LH:    //原本左子树比右子树高，则作左平衡处理  
  74.                     LeftBalance(pAT);  
  75.                     lower = TRUE;  
  76.                     break;  
  77.                 case EH:    //原本左右子树等高，现左子树比右子树高1  
  78.                     (*pAT)->nBf = LH;  
  79.                     lower = FALSE;  
  80.                     break;  
  81.                 case RH:    //原本右子树比左子树高，现左左子树等高  
  82.                     (*pAT)->nBf = EH;  
  83.                     lower = TRUE;  
  84.                     break;  
  85.             }  
  86.         }  
  87.     }  
  88.     return 1;  
  89. }  

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. AVLTree FindMin(AVLTree AT)  
  2. {  
  3.     //查找AT中最小的元素  
  4.     while(AT && AT->LChild)  
  5.     {  
  6.         AT = AT->LChild;  
  7.     }  
  8.     return AT;  
  9. }  
  10.   
  11. AVLTree GetParent(AVLTree AT, DataType c)  
  12. {  
  13.     if(!AT || AT->cData == c)  
  14.         return NULL;  
  15.     if((AT->LChild && AT->LChild->cData == c) ||  
  16.             (AT->RChild && AT->RChild->cData == c))  
  17.         return AT;  
  18.     else if((AT->LChild && c < AT->LChild->cData))  
  19.         return GetParent(AT->LChild, c);  
  20.     else  
  21.         return GetParent(AT->RChild, c);  
  22. }  
  23.   
  24. AVLTree FindATNode(AVLTree AT, DataType c)  
  25. {  
  26.     if(!AT)  
  27.         return NULL;  
  28.     else if(AT->cData == c)  
  29.         return AT;  
  30.     else if(c < AT->cData)  
  31.     {  
  32.         return FindATNode(AT->LChild, c);  
  33.     }  
  34.     else  
  35.     {  
  36.         return FindATNode(AT->RChild, c);  
  37.     }  
  38. }  

现在对这种实现方法作一点小小的分析。

1、至于时间复杂度的分析就不必多说了，所有的算法的时间复杂度都为log2N。

2、从代码的数量可以看出这并不是一种好的实现方法，因为它的思路不太清晰和直观，操作实现比较复杂，还要用到二重指针，增加了程序出错的机会。

3、导致复杂的原因主要有两个，

1）第一个就是在高度信息储存方法上，不是采用每个结点保存自己作为一棵树的深度，而是保存着左右子树之差（左子树的深度 - 右子树的深度），从而产生了大量的判断和switch语句，让人眼花瞭乱，并且影响程序的效率和易读性，难以维护，所以用一个变量记录树的高度会让程序思路更清晰。

2）再者，在这里的旋转、插入的删除操作都要调节结点并改变指向结点的指针变量的值，在C语言中是没有引用的（C++有），所以就要用到双重指针，这无疑加大了程序的复杂度，而且使程序更容易出错。而避免这样的情况的做法是很简单的，只需要做一个简单的修改。就是让旋转插入等操作的返回值为指向结点的指针，而不是一个标志操作是否成功的状态值。而且这样做还有一个好处，就是通常最后插入的数据总是最先被访问，这样就可以根据返回的结点的指针马上访问该结点，而不用再在整棵树中查找。


算法如有错误，还请各位读者指出，谢谢！

改进后的算法会在下一篇文章（AVL树的插入删除查找算法实现和分析-2（树高度法））中给出。


我自己写的代码， 在rhel6下可以运行，粘贴上来，在另外一个高度法，会进行注释的。 用C写的。有错记得提醒我哦，谢谢。 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define LH 1
#define EH 0
#define RH -1

#define TRUE 1
#define FALSE 0

typedef struct avl_tree_s {
	int data;
	int bf;
	struct avl_tree_s *lchild;
	struct avl_tree_s *rchild;
}avl_tree_t;

avl_tree_t *get_min(avl_tree_t *tree)
{
        while(tree && tree->lchild) {
                tree = tree->lchild;
        }

        return tree;
}

avl_tree_t *get_parent(avl_tree_t *tree, int data) 
{
        if(!tree || tree->data == data) {
                return NULL;
        }

        if((tree->lchild && tree->lchild->data == data) 
                || (tree->rchild && tree->rchild->data == data)) {
                return tree;
        }else if(tree->data > data) {
                return get_parent(tree->lchild, data);
        }else {
                return get_parent(tree->rchild, data);
        }
        
        return NULL;                                
}


void l_roate(avl_tree_t **t) 
{
	avl_tree_t *r = NULL;
	if(!t || !(*t)) {
		return ;
	}
	
	r = (*t)->rchild;	
	(*t)->rchild = r->lchild;
	r->lchild = (*t);

	*t = r;	
}

void r_roate(avl_tree_t **t) 
{
	avl_tree_t *l = NULL;
	if(!t || !(*t)) {
		return ;
	}
	
	l = (*t)->lchild;	
	(*t)->lchild = l->rchild;
	l->rchild = (*t);

	*t = l;	
}

void left_balance(avl_tree_t **t)
{
	avl_tree_t *l = NULL;
	avl_tree_t *lr = NULL;
	if(!t || !(*t)) {
		return ;
	}

	l = (*t)->lchild;

        if(!l) {
                return;
        }

	switch(l->bf) {
		case LH:
			(*t)->bf = l->bf = EH;
			r_roate(t);
			break;
		case RH:
			lr = l->rchild;	
			switch(lr->bf) {
				case LH:
					(*t)->bf = RH;
					l->bf = EH;
					break;
				case EH:
					(*t)->bf = l->bf = EH;
					break;
				case RH:
					(*t)->bf = EH;		
					l->bf = LH;
					break;
			}	

			lr->bf = EH;
			l_roate(&((*t)->lchild));
			r_roate(t);
	}
	
}

void right_balance(avl_tree_t **t)
{
	avl_tree_t *r = NULL;
	avl_tree_t *rl = NULL;
	if(!t || !(*t)) {
		return ;
	}

	r = (*t)->rchild;

        if(!r) {
                return;
        }

	switch(r->bf) {
		case RH:		
			(*t)->bf = EH;			
			r->bf = EH;
			l_roate(t);
			break;
		case LH:
			rl = r->lchild;
			switch(rl->bf) {
				case LH:
					(*t)->bf = EH;
					r->bf = RH;	
					break;
				case EH:
					(*t)->bf = r->bf = EH;
					break;
				case RH:	
					(*t)->bf = LH;
					r->bf = EH;
					break;
			}	
			rl->bf = EH;
	
			r_roate(&((*t)->rchild));
			l_roate(t);
	}
}

int *del_node(avl_tree_t **tree, int data)
{
        avl_tree_t *node = NULL;       
        avl_tree_t *min = NULL;
        avl_tree_t *parent = NULL;
        static int lower = FALSE;

        if(!tree || !(*tree)) {
                return FALSE;
        }

        node = *tree;

        if(node->data == data) {
                //find
                //get the replace node
                min = get_min(node->rchild);
                if(min != NULL) {
                        node->data = min->data;
                        if(min == node->rchild) {
                               (*tree)->rchild = min->rchild;
                        }else {
                                parent = get_parent(node->rchild, min->data);
                                if(parent)
                                        parent->lchild = min->rchild;
                        }
                }else {
                        min = node;
                        (*tree) = node->lchild;
                }
                free(min);

                lower = TRUE;
        }
        else if(node->data > data) {
                //left
                if(del_node(&(node->lchild), data) != TRUE) {
                        return FALSE;
                }

                node = *tree;   //tree可能变化，重新赋值

                if(lower == TRUE) {
                       switch(node->bf) {
                               case LH:
                                        node->bf = EH;
                                        lower = TRUE;
                                        break;
                               case EH:
                                        node->bf = RH;
                                        lower = FALSE;
                                        break;
                               case RH:
                                        right_balance(tree);
                                        lower = TRUE;
                                        break;
                       } 
                }
        }else {
                //right
                if(del_node(&(node->rchild), data) != TRUE) {
                        return FALSE;
                }
                node = *tree;   //tree可能变化，重新赋值

                if(lower == TRUE) {
                       switch(node->bf) {
                               case LH:
                                        left_balance(tree);
                                        lower = TRUE;
                                        break;
                               case EH:
                                        node->bf = LH;
                                        lower = FALSE;
                                        break;
                               case RH:
                                        node->bf = EH;
                                        lower = TRUE;
                                        break;
                       } 
                }
        }

        return TRUE;
}

void show_first(avl_tree_t *tree)
{
	if(tree) {
		printf("%d ", tree->data);
		show_first(tree->lchild);
		show_first(tree->rchild);
	}
}

void show_center(avl_tree_t *tree)
{
	if(tree) {
		show_center(tree->lchild);
		printf("%d ", tree->data);
		show_center(tree->rchild);
	}
}

void show_after(avl_tree_t *tree)
{
	if(tree) {
		show_after(tree->lchild);
		show_after(tree->rchild);
		printf("%d ", tree->data);
	}
}

void del_tree(avl_tree_t *tree)
{
	if(tree) {
		free(tree);
		tree = NULL;
	}
}

void destroy_tree(avl_tree_t *tree)
{
	if(tree) {
		destroy_tree(tree->lchild);
		destroy_tree(tree->rchild);
		del_tree(tree);
	}
}

int avl_insert(avl_tree_t **tree, int data, int *taller)
{
	if(tree == NULL || !taller) {
		return FALSE;
	}

	if(*tree == NULL) {
		(*tree) = (avl_tree_t *)calloc(sizeof(avl_tree_t), 1);				
		if((*tree) == NULL) {
			*taller = 0;
			return FALSE;
		}
		(*tree)->data = data; 
		(*tree)->bf = EH;
		*taller = TRUE;
			
		return TRUE;
	}

	if((*tree)->data == data) {
		*taller = FALSE;
		return FALSE;
	}else if ((*tree)->data > data) {
		//left	
		if(avl_insert(&((*tree)->lchild), data, taller) != TRUE) {
			return FALSE;
		}

		if(*taller == TRUE) {
			switch((*tree)->bf) {
				case LH:
					left_balance(tree);
					*taller = FALSE;
					break;
				case EH:
					(*tree)->bf = LH;
					*taller = TRUE;
					break;
				case RH:
					(*tree)->bf = EH;
					*taller = FALSE;
					break;
			}			
		}	
	}else if ((*tree)->data < data) {
		if(avl_insert(&((*tree)->rchild), data, taller) != TRUE) {
			return FALSE;
		}

		if(*taller == TRUE) {
			switch((*tree)->bf) {
				case LH:
					(*tree)->bf = EH;
					*taller = FALSE;
					break;
				case EH:
					(*tree)->bf = RH;
					*taller = TRUE;
					break;
				case RH:
					right_balance(tree);
					*taller = FALSE;
					break;	
			}
		}

	}

	return TRUE;
}

int avl_tree_init(avl_tree_t **tree, int *data, int n)
{
	int i = 0;
	int taller = 0;

	if( !data || n <= 0 || !tree) {
		return -1;	
	}

	for(i = 0; i < n; i++) {
		avl_insert(tree, data[i], &taller);
		printf("xianxu:");
		show_first(*tree);
		printf("\nzhongxu:");
		show_center(*tree);
		printf("\n");
	}	

	return 0;
}

int main()
{
	int data[10] = {3, 2, 1, 4, 5, 6, 7, 10, 9, 8};
	avl_tree_t *tree = NULL;		
	
	avl_tree_init(&tree, data, 10);

	show_first(tree);
	printf("\n");
	show_center(tree);
	printf("\n");
	show_after(tree);
	printf("\n");

        del_node(&tree, 7);
        //del_node(&tree, 5);
        del_node(&tree, 4);

        printf("-------\n");
        show_first(tree);
	printf("\n");
	show_center(tree);
	printf("\n");
	show_after(tree);
	printf("\n");

	destroy_tree(tree);	
	tree = NULL;

	return 0;
	
}




猪神川
关注
专栏目录
平衡二叉树的平衡实现--插入、删除
Allen_Walker_QAQ的博客
06-13 2366
插入    若向平衡二叉树中插入一个新结点后破坏了平衡二叉树的平衡性。首先要找出插入新结点后失去平衡的根结点的指针最小子树。然后再调整这个子树中有关结点之间的链接关系，使之成为新的平衡子树。当失去平衡的最小子树被调整为平衡子树后，原有其他所有不平衡子树无需调整，整个二叉排序树就又成为一棵平衡二叉树。失去平衡的最小子树是指以离插入结点最近，且平衡因子绝对值大于 1 的结点作为根的子树。假设用 A 表...
AVL树的插入删除遍历等操作
01-04
AVL树的各种操作：包括插入 删除 遍历 平衡旋转等
【查找结构3】平衡二叉查找树 [AVL]
ccnunlp的专栏
03-08 188
在上一个专题中，我们在谈论二叉查找树的效率的时候。不同结构的二叉查找树，查找效率有很大的不同（单支树结构的查找效率退化成了顺序查找）。如何解决这个问题呢？关键在于如何最大限度的减小树的深度。正是基于这个想法，平衡二叉树出现了。   平衡二叉树的定义 （AVL—— 发明者为Adel'son-Vel'skii 和 Landis）   平衡二叉查找树，又称 ...
AVL树的插入删除查找算法实现和分析-1
weixin_33682719的博客
06-20 144
至于什么是AVL树和AVL树的一些概念问题在这里就不多说了，下面是我写的代码，里面的注释非常详细地说明了实现的思想和方法。 因为在操作时真正需要的是子树高度的差，所以这里采用-1，0，1来表示左子树和右子树的高度差，而没有使用记录树的高度的方法。 代码如下： typedef struct AVLNode {     DataType cData;     int nBf;       ...
AVL树的插入删除查找算法实现和分析-2（树高度法）
chuanhehuan1的专栏
11-25 948
在本博客的也转载了 AVL树的插入删除查找算法实现和分析-2（树高度法）
AVL.rar_AVL 存储结构建立删除查找算法的实现
09-23
在`AVL.cpp`文件中，很可能包含了AVL树的数据结构定义、插入、删除和查找函数的实现。这些函数会使用递归或者迭代的方式遍历和操作树的节点，同时结合旋转操作以保持树的平衡。通过对这些函数的分析和理解，我们可以...
AVL树插入删除算法详解（有图） -- C++语言实现
FreeeLinux's blog
08-14 1万+
一：AVL树介绍 AVL树本质上还是一棵二叉搜索树，它的特点是： 1.本身首先是一棵二叉搜索树。 2.带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。在本文中用分别用-1，0，1定义左边树高，等高，右边树高。平衡因子用m_bf表示。 也就是说，AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）。 二：插入算法 由于AVL树具有BST树的
Avl树插入、删除c++实现
03-11
总的来说，实现AVL树的插入和删除功能需要理解二叉查找树的性质、AVL树的平衡条件以及旋转操作的原理。在C++中编写这样的代码，不仅可以提升算法能力，还能锻炼对数据结构的理解和代码优化技巧。
数据结构课程设计平衡二叉排序树的三种基本功能：查找、插入、删除。
06-12
1. 本程序实现平衡二叉排序树的三种基本功能：查找、插入、删除。 2. 初始平衡二叉树为空树，由用户输入要创建树的结点数，并输入每个结点的权值，以整数形式表示，边输入边排序构成平衡二叉排序树。 3. 对二叉树的插入和删除操作包含查找操作。插入的过程就要查找二叉树中是否存在和将插入结点的权值相等的结点，如果存在则不插入该结点。删除操作中如果指定要删除某个权值的结点，则也要先查找二叉树中是否存在与此权值相等的结点，若无，则删除失败。
AVL树插入删除
我就是王大大的博客
08-29 780
AVL树是一种平衡二叉树，其每个节点的左右子树高度最多差1，空树高度定为－1，当左右的高度超过1，即失去了平衡，不是AVL树了。 private static class AVLNode{ AVLNode (AnyType element) {this(element ,null,null);} AVLNode(AnyTape element,AVLNode left,AVLNode r
平衡二叉树（AVL）的创建、插入、删除
D20152107的博客
09-11 3426
一、概念 平衡二叉树（下文称AVL）是满足每个结点的左右子树高度（亦称深度）之差在{0，1，-1}这个范围内的二叉排序树（二叉排序树也叫二叉搜索树）。 AVL的优势是在查找时避免了出现一般二叉排序树查找的最坏情况。但是AVL在经过插入或删除结点的操作之后可能出现不平衡的情况，所以每次插入或删除完之后要判断是否平衡，不平衡就需要rebalance.这会增加插入删除的复杂度。 二、AVL的创...
查找算法进阶：利用树的查找（二叉排序树、AVL树、多路查找树、B树）
时间有泪
11-03 461
1 二叉搜索树 2 ALV树 3 例题
平衡二叉树(AVL树)的平衡原理以及插入,删除操作
热门推荐
weixin_36888577的博客
02-13 3万+
文章目录AVL树的定义AVL树不平衡的情况左子树的左子树插入结点 (左左)右子树的右子树插入节点左子树的右子树插入节点右子树的左子树插入节点删除结点插入节点更复杂的情况所有代码测试结果 AVL树的定义 平衡因子 : 树中某结点其左子树的高度和右子树的高度之差 AVL树中的任意一个结点, 其平衡因子的绝对值小于2 AVL树是一种特殊的二叉搜索树 (BST树), 相对于数据极端情况下, 二叉搜索树会...
BST 存储结构建立（插入）、删除、 查找算法的实现及应用
idevede的博客
02-13 1万+
这是最后一次数据结构实验，排序部分
平衡二叉搜索树：AVL树的实现与分析 以及 统一重平衡算法 （C++）
amoscykl的博客
08-11 1480
平衡二叉搜索树 既然二叉搜索树的性能主要取决于高度,故在节点数目固定的前提下,应尽可能地降低高度。 相应地,应尽可能地使兄弟子树的高度彼此接近,即全树尽可能地平衡。   等价变换 等价二叉搜索树：若两棵二叉搜索树的中序遍历序列相同,则称它们彼此等价;反之亦然。   旋转调整 最基本的修复手段，通过围绕特定节点的旋转，实现等价前提下的局部拓扑调整。 zig和zag：    ...
AVL树删除
早起的虫儿灬
05-16 3621
AVL Tree与BST 由于AVL树本身就是一颗自平衡的BST，因此其的删除比起BST仅仅多了删除后平衡的调整   查找: AVL树中一定不存在两个值大小相同的节点 从AVL树根开始向下搜索，根据意图删除值与当前节点值大小关系进行下一步操作: 1、  当前节点值大于意图删除值，保存当前节点并在当前节点的左子树中继续查找意图删除值 2、  当前节点值小于意图删除值，保存当前节点并在当
平衡树——AVL算法
_int_me的博客
05-02 1172
有关AVL树的解析
探索AVL树的平衡之美：左右子树高度差与算法实现
资源摘要信息: "AVL_tree.zip"包含了关于AVL树的详细介绍和实现代码。AVL树是一种自平衡的二叉搜索树，由Adelson-Velsky和Landis在1962年提出，因此得名。它是二叉搜索树的一种，它通过旋转来保持平衡，以确保任何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值