平衡二叉搜索树

最新推荐文章于 2024-02-23 11:14:38 发布
最新推荐文章于 2024-02-23 11:14:38 发布
阅读量475 收藏
点赞数
分类专栏： 数据结构 C 文章标签： 数据结构 avl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y920036515/article/details/120494621
版权

全知识整理目录

数据结构整理的目录包括了许多的数据结构相关知识。

目录

概述

旋转的介绍

左单旋转

右单旋转

左右双旋

代码逻辑

结点的创建

左单旋

右单旋

 完整代码

概述

什么是平衡二叉搜索树？

首先需要了解一下什么是二叉搜索树？

左子树都小于根节点，右子树都大于根节点，这样的树就是二叉搜索树。

平衡二叉搜索树就是，不仅要是二叉搜索树，还要是平衡的。每个节点都有一个平衡因子，平衡因子为-1，0，1（平衡因子 = 右子树的高度-左子树的高度）的就是平衡二叉搜索树。

要学习的其实就是，插入和删除的时候，二叉树的平衡因子会变化，那么这就是需要学习和了解的难点重点了。

旋转的介绍

左单旋转

如下图所示，在当前平衡的结点上加上一个5，那么3的平衡因子此时就为2，造成不平衡，所以需要，左旋转（逆时针旋转）。

右单旋转

右单旋转，与做单旋转相反，是指新插入的结点位于，左侧子树，且平衡因子不满足。

下图以原本平衡的树，再插入一个2结点，那么就会有右单旋转，恰好跟左单旋转相反，左右旋转是指结点移动的方向。

左右双旋

如下图如果想要插入37，就会导致平衡因子不符合要求，所以需要做出调整。

是怎么样调整的呢？

动图的调整方式可能比较快，可以看见红色的两条分支是需要调整的，而下面的一条就是左旋，上面的一条就是右旋。后面也有详细分解步骤。

 第一次左旋，之后发现平衡因子还是不满足。继续右旋。

 第二次右旋

 有左右双旋，肯定也有右左双旋，右左双旋就不介绍了，本质上跟左右双旋是一样的。

无论怎么旋，只要记得，从下往上，第一个不满足平衡因子的地方开始旋转，往上继续看，还有多少个不满足的平衡因子就旋转多少次，这样就能够解决了。

代码逻辑

首先需要了解树结点的定义


typedef int ElemType;
typedef struct BSTNode
{
	ElemType key;
	int bf;
	struct BSTNode *lchild,*rchild;
}BSTNode,*BSTree;

结点的创建

typedef enum
{
	EH = 0,
	LH = 1,
	RH = -1	
}bh_t;
 
 
typedef enum
{
	FALSE = 0,
	TRUE = 1
}bool_t;

要实现旋转操作，肯定需要平衡因子发生变化，这里就需要了解插入结点到树中的代码。

插入代码的大概逻辑是：

  1. 树如果为空的话，直接插入什么也不用考虑。
  2. 树不为空，判断是大于根节点还是小于根节点，从而找到插入到左边还是右边。
  3. 然后结点小于父节点的值，就插入到左边，否则插入到右边，相同的数字不予插入。
  4. 再调整平衡因子，平衡因子的调整会根据父节点进行调整，首先插入结点在子树的父节点++，在子节点--，然后再判断父节点的平衡因子（bf），再根据左旋，右旋，左右旋的函数进行调整。
bool_t InsertAVL(BSTree *t,ElemType e,bool_t *taller)
{
	if(NULL == t)    //树为空的情况
		return FALSE;
	if(NULL == *t)    
	{
		*t=(BSTree)malloc(sizeof(BSTNode));
		if(NULL == *t)
			return FALSE;
		(*t)->key=e;
		(*t)->lchild=(*t)->rchild=NULL;
		(*t)->bf=EH;
		*taller=TRUE;
	}
	else
	{
		if(e==(*t)->key)    
		{
			*taller=FALSE;
			return FALSE;
		}
		if(e<(*t)->key)
		{
			if(FALSE == InsertAVL(&((*t)->lchild),e,taller))
				return FALSE; 
			if(*taller)
			{
				switch((*t)->bf)
				{
					case LH:
						LeftBalance(t);
						*taller=FALSE;
						break;
					case EH:
						(*t)->bf=LH;
						*taller=TRUE;
						break;
					case RH:
						(*t)->bf=EH;
						*taller=FALSE;
						break;
				}
			}
		}
		else
		{
			if(FALSE == InsertAVL(&((*t)->rchild),e,taller))
				return FALSE; 
			if(*taller)
			{
				switch((*t)->bf)
				{
					case RH:
						RightBalance(t);
						*taller=FALSE;
						break;
					case EH:
						(*t)->bf=RH;
						*taller=TRUE;
						break;
					case LH:
						(*t)->bf=EH;
						*taller=FALSE;
						break;
				}
			}
		}
	}
	return TRUE;
}

左单旋

void L_Rotate(BSTree *p)
{
	BSTree rc=(*p)->rchild;
	(*p)->rchild=rc->lchild;
	rc->lchild=*p;
	*p=rc;
}

右单旋

void R_Rotate(BSTree *p)
{
	BSTree lc=(*p)->lchild;
	(*p)->lchild=lc->rchild;
	lc->rchild=*p;
	*p=lc;
}

 完整代码

#include <stdio.h>
#include <malloc.h>
 
typedef enum
{
	EH = 0,
	LH = 1,
	RH = -1	
}bh_t;
 
 
typedef enum
{
	FALSE = 0,
	TRUE = 1
}bool_t;
 
typedef int ElemType;
 
typedef struct BSTNode
{
	ElemType key;
	int bf;
	struct BSTNode *lchild,*rchild;
}BSTNode,*BSTree;
 
 
void InOrderTraverse(BSTree root)
{
	if(NULL != root)
	{
		InOrderTraverse(root->lchild);
		printf("%d\t",root->key);
		InOrderTraverse(root->rchild);
	}
}
 
 
void PreOrderTraverse(BSTree root)
{
	if(NULL != root)
	{
		printf("%d\t",root->key);
		PreOrderTraverse(root->lchild);
		PreOrderTraverse(root->rchild);
	}
}
 
 
void R_Rotate(BSTree *p)
{
	BSTree lc=(*p)->lchild;
	(*p)->lchild=lc->rchild;
	lc->rchild=*p;
	*p=lc;
}
 
 
void L_Rotate(BSTree *p)
{
	BSTree rc=(*p)->rchild;
	(*p)->rchild=rc->lchild;
	rc->lchild=*p;
	*p=rc;
}
 
 
void LeftBalance(BSTree *T)
{
	BSTree lc=(*T)->lchild;
	BSTree rd = lc->rchild;
	switch(lc->bf)
	{
		case LH:
			(*T)->bf=lc->bf=EH;
			R_Rotate(T);
			break;
		case RH:
			switch(rd->bf)
			{
				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));
			R_Rotate(T);
			break;
	}
}
 
 
void RightBalance(BSTree *T)
{
	BSTree rc=(*T)->rchild;
	BSTree ld=rc->lchild;
	switch(rc->bf)
	{
		case RH:
			(*T)->bf=rc->bf=EH;
			L_Rotate(T);
			break;
		case LH:
			switch(ld->bf)
			{
				case RH:
					(*T)->bf=LH;
					rc->bf=EH;
					break;
				case EH:
					(*T)->bf=rc->bf=EH;
					break;
				case LH:
					(*T)->bf=EH;
					rc->bf=RH;
					break;
			}
			ld->bf=EH;
			R_Rotate(&((*T)->rchild));
			L_Rotate(T);
			break;
	}
}
 
 
bool_t InsertAVL(BSTree *t,ElemType e,bool_t *taller)
{
	if(NULL == t)
		return FALSE;
	if(NULL == *t)
	{
		*t=(BSTree)malloc(sizeof(BSTNode));
		if(NULL == *t)
			return FALSE;
		(*t)->key=e;
		(*t)->lchild=(*t)->rchild=NULL;
		(*t)->bf=EH;
		*taller=TRUE;
	}
	else
	{
		if(e==(*t)->key)
		{
			*taller=FALSE;
			return FALSE;
		}
		if(e<(*t)->key)
		{
			if(FALSE == InsertAVL(&((*t)->lchild),e,taller))
				return FALSE; 
			if(*taller)
			{
				switch((*t)->bf)
				{
					case LH:
						LeftBalance(t);
						*taller=FALSE;
						break;
					case EH:
						(*t)->bf=LH;
						*taller=TRUE;
						break;
					case RH:
						(*t)->bf=EH;
						*taller=FALSE;
						break;
				}
			}
		}
		else
		{
			if(FALSE == InsertAVL(&((*t)->rchild),e,taller))
				return FALSE; 
			if(*taller)
			{
				switch((*t)->bf)
				{
					case RH:
						RightBalance(t);
						*taller=FALSE;
						break;
					case EH:
						(*t)->bf=RH;
						*taller=TRUE;
						break;
					case LH:
						(*t)->bf=EH;
						*taller=FALSE;
						break;
				}
			}
		}
	}
	return TRUE;
}
 
 
BSTree searchAVL(BSTree t,ElemType key)
{
	BSTree p=t;
	while(p)
	{
		if(p->key==key)
			return p;
		else if(p->key<key)
			p=p->rchild;
		else
			p=p->lchild;
	}
	return p;
}
 
static void destroy(BSTree *t)
{
	if(NULL != *t)
	{
		destroy(&((*t)->lchild));
		destroy(&((*t)->rchild));
		free(*t);
		*t = NULL;
	}
	return;
}
void destroyAVL(BSTree root)
{
	if(NULL != root)
	{
		destroy(&root);
	}
	return;
}
 
int main(int argc,char *argv[])
{
	BSTree root=NULL,r;
	bool_t taller=FALSE;
	int array[]={13,24,37,90,53};
	int i = 0;
	for(i=0;i<5;i++)
		InsertAVL(&root,array[i],&taller);
	printf("inorder traverse\n");
	InOrderTraverse(root);
 
	printf("\npreorder traverse\n");
	PreOrderTraverse(root);
 
	printf("\nsearch key\n");
	r=searchAVL(root,37);
	if(r)
	{
		printf("%d\n",r->key);
	}
	else
	{
		printf("not find!\n");
	}
	destroyAVL(root);
	root = NULL;
}

 

ybbgrain
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉搜索树和平衡二叉树
VeedeWeng的博客
05-11 466
一、二叉搜索树 二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树。 二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质： 非空左子树的所有键值小于其根结点的键值； 非空右子树的所有键值大于其根结点的键值； 左、右子树都是二叉搜索树。 1.二叉搜索树的查找操作：Find 查找从根节点开始，如果树为空，返回NULL；若搜索树非空，则根结点关键字和X进行比较，并进行不同处理； ①若X小于根结点键值，只需在左子树中继续搜索； ②若X大于根结点键值，只需在右子树中继续
二叉查找树的平衡（DSW）
让我思考一下
12-02 1004
树适合于表示某些领域的层次结构（比如Linux的文件目录结构），使用树进行查找比使用链表快的多，理想情况下树的查找复杂度O(log(N))，而链表为O(N)，但理想情况指的是什么情况呢？一般指树是完全平衡的时候。哪最坏的情况是什么呢？就是树退化为链表的时，这时候查找的复杂度与链表相同。就失去了树结构的意义。所以树的平衡是非常重要的，这一节我们主要讨论树的平衡问题。 如果树中任一节点的两个子树的高...
动图详解平衡树——平衡的二叉搜索树
tunmang5421的博客
04-10 1335
【多动图警告】本文详细介绍了平衡树，加了一些动图和自己的理解
平衡二叉树（AVL）图解与实现
小张的专栏
10-31 6万+
个人技术博客：http://blog.ztgreat.cn 平衡二叉树（Balanced BinaryTree）又被称为AVL树。它具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。   平衡二叉树一般是一个有序树，它具有二叉树的所有性质，其遍历操作和二叉树的遍历操作相同。但是由于其对二叉树施加了额外限制，因而其添加、删除操作都必须...
二叉查找树与平衡二叉树
热门推荐
金发只是水一下的博客
08-29 8万+
二叉查找树 　　二叉查找树，也称二叉搜索树，或二叉排序树。其定义也比较简单，要么是一颗空树，要么就是具有如下性质的二叉树： （1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3） 任意节点的左、右子树也分别为二叉查找树； （4） 没有键值相等的节点。 　　如上图所示，是不同形态...
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2621
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
将升序数组转化为平衡二叉搜索树
07-27
将一个升序数组转化为平衡二叉搜索树是一种常见的算法问题。平衡二叉搜索树是一种特殊的二叉搜索树，它的左子树和右子树的高度差不超过1，以确保树的查找效率。 要将升序数组转化为平衡二叉搜索树，我们可以使用...
二叉搜索树_二叉搜索树_源码
10-04
为了克服这个问题，可以使用自平衡二叉搜索树，如AVL树或红黑树，它们能保证树的高度大致平衡，从而保持高效的操作性能。 在源代码中，可能会有主函数`main()`来测试上述功能，通过创建一些示例数据，然后进行插入...
Python实现二叉搜索树
09-21
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树数据...虽然在最坏的情况下，二叉搜索树的性能可能会退化成链表，但在平均情况下，其性能表现良好，且通过平衡技术（如AVL树或红黑树）可以进一步提高性能。
java实现 二叉搜索树功能
08-27
Java 实现二叉搜索树功能 二叉搜索树是一种特殊的二叉树，它的每个节点都含有一个...二叉搜索树的优点是可以快速地查找、插入和删除元素，但是它的缺点是需要维护树的平衡，以保证查找、插入和删除操作的效率。
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
平衡二叉搜索树（AVLTree）
是胖胖没错了的博客
08-08 1450
AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。 一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： 它的左右子树都是AVL树 左右
数据结构之平衡二叉搜索树
最新发布
m0_69767208的博客
02-23 680
AVL是一种自平衡二叉搜索树（self-balancing binary search tree）的数据结构，它的名称来源于其发明者G.M. Adelson-Velsky和E.M. Landis。AVL树通过在每次插入或删除节点时进行旋转操作，来确保树的高度始终保持在一个较小的范围内，从而保持树的平衡性。AVL树的平衡性是通过节点的高度差（即左子树高度和右子树高度之差）来衡量的。在一个平衡的AVL树中，任何节点的左子树和右子树的高度差不超过1。
平衡二叉搜索树（AVL）详解
芮萌萌的博客
07-09 3万+
1.二叉搜索树（Binary Sort Tree） 二叉搜索树，又称之为二叉排序树（二叉查找树），它或许是一棵空树，或许是具有以下性质的二叉树： 若他的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别是二叉搜索树 二叉搜索树的这种特性，使得我们在此二叉树上查找某个值就很方便了，从根节点开始，若要寻找的值...
AVL树（平衡二叉搜索树）
langk_的博客
09-03 3283
带你手撕AVL树，左单旋，右单旋，左右双旋，右左双旋
平衡二叉搜索树（Balanced Binary Tree）
Garbage2Beginner的博客
02-19 609
平衡二叉搜索树是一种结构平衡的二叉搜索树，它的每个结点的左右两颗子树的高度差都不超过一的二叉树。
was not declared in this scope
ybbgrain的历程
11-14 1万+
int main(){ int R[]={12,65,11,28,56,68,21}; int a=sizeof(R)/sizeof(R[0]); InsertSort(R,a); return 1; } int InsertSort(int R[],int n){ } 代码如上，报错如下 9 16 D:\C\test.cpp [Error] 'InsertSort' was not declared in this scope 是因为自定义函数要写在主...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ybbgrain

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值