数据结构——平衡二叉树

最新推荐文章于 2024-01-04 00:37:33 发布
最新推荐文章于 2024-01-04 00:37:33 发布
阅读量466 收藏 3
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42106610/article/details/127699582
版权

一、定义：

        平衡二叉树（Balanced Binary Tree）,又叫AVL树。当非空树时，任一节点左右子树高度差绝对值不大于1，这种树叫做平衡二叉树。

        平衡因子：左右子树的高度差叫做这棵树的平衡因子BF（Balance Factor）.BF（T）=hl-hr，其中hl和hr分别是树T的左右子树高度。

二、性质：

        它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。常用算法有红黑树、AVL、Treap、伸展树等。在平衡二叉搜索树中，我们可以看到，其高度一般都良好地维持在O(log(n))，大大降低了操作的时间复杂度。

三、操作：

        AVL *creat（）；建树

        Elementtype find（）;查找

        void insert（）；插入

        Elementtype del（）；删除

四、代码：

        头文件： 

#ifndef AVLTREE_H
#define AVLTREE_H
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
typedef struct tree_node AVLT;
typedef int Elementtype;
struct tree_node{
	Elementtype value;
	AVLT *left;
	AVLT *right;
	int bf;
};
typedef struct stack_node STNode;
typedef AVLT* Element;
struct stack_node{
	Element value;
	STNode *next;
};
typedef struct {
	STNode *top;
	STNode *bottom;
}Stack;
#endif

AVLT *creatNode(Elementtype value);				//生成新结点 
AVLT *insertAVL1(AVLT *pTr,Elementtype value);	//递归插入
AVLT *insertAVL2(AVLT *pTr,Elementtype value);	//非递归插入
AVLT *delAVL1(AVLT *pTr,Elementtype value);		//递归删除
AVLT *delAVL2(AVLT *pTr,Elementtype value);		//非递归删除

void cleanAVL(AVLT **pTr);						//清空树
void Preordertraversal(AVLT *pTr);				//前序递归遍历
void Inordertraversal(AVLT *pTr);				//中序递归遍历 
void Postordertraversal(AVLT *pTr);				//后续递归遍历 

int getHAVL(AVLT *pTr);		//求树高
int getBalance(AVLT *pTr);	//求平衡因子
int max(int a,int b);		//取大值

Elementtype maxNode(AVLT *pTr);	//取左子树的最大值
Elementtype minNode(AVLT *pTr);	//取右子树的最小值

AVLT *rotation(AVLT *pTr);	//旋转封装 
AVLT *ll(AVLT *pTr);		//左左旋转 
AVLT *rr(AVLT *pTr);		//右右旋转 
AVLT *lr(AVLT *pTr);		//左右旋转 
AVLT *rl(AVLT *pTr);		//右左旋转 

Stack *creatStack();
int isemptyStack(Stack *pStack);
void pushStack(Stack *pStack,Element value);
Element popStack(Stack *pStack);
void cleanStack(Stack **pStack);

        函数实现：

#include "avltree.h"
AVLT *creatNode(Elementtype value){				//生成新结点
	AVLT *pNode=(AVLT*)malloc(sizeof(AVLT));
	pNode->value=value;
	pNode->left=pNode->right=NULL;
	pNode->bf=0;
	return pNode;
}
AVLT *insertAVL1(AVLT *pTr,Elementtype value){	//递归插入
	if(!pTr){
		pTr=creatNode(value);
	}else{
		if(value<pTr->value){
			pTr->left=insertAVL1(pTr->left,value);
			pTr=rotation(pTr);
		}else if(value>pTr->value){
			pTr->right=insertAVL1(pTr->right,value);
			pTr=rotation(pTr); 
		}
	}
	return pTr;
}
AVLT *insertAVL2(AVLT *pTr,Elementtype value){	//非递归插入
	AVLT *pNode=creatNode(value);
	AVLT *parent=NULL,*gparent=parent;
	AVLT *ptemp=pTr;
	Stack *pStack=creatStack();
	if(ptemp){
		while(ptemp){
			parent=ptemp;
			pushStack(pStack,parent);
			if(value>ptemp->value){
				ptemp=ptemp->right;
				if(!ptemp){
					parent->right=pNode;
				}
			}else if(value<ptemp->value){
				ptemp=ptemp->left;
				if(!ptemp){
					parent->left=pNode;
				}
			}
		} 
	}else{
		pTr=pNode;
	}
	while(!isemptyStack(pStack)){
		parent=popStack(pStack);
		parent->bf=getBalance(parent);
		if(parent->bf==2||parent->bf==-2){
			parent=rotation(parent);
		}
		if(!isemptyStack(pStack)&&parent->value>pStack->top->value->value){
			pStack->top->value->right=parent;
		}else if(!isemptyStack(pStack)&&parent->value<pStack->top->value->value){
			pStack->top->value->left=parent;
		}else{
			pTr=parent;
		}	
	}
	cleanStack(&pStack);
	return pTr;
}
AVLT *delAVL1(AVLT *pTr,Elementtype value){		//递归删除 
	if(pTr){
		if(value<pTr->value){
			pTr->left=delAVL1(pTr->left,value);
			pTr=rotation(pTr);
		}else if(value>pTr->value){
			pTr->right=delAVL1(pTr->right,value);
			pTr=rotation(pTr);
		}else{
			if(pTr->left&&pTr->right){
				Elementtype tempvalue=maxNode(pTr);
				pTr->value=tempvalue;
				pTr->left=delAVL1(pTr->left,tempvalue);
				pTr=rotation(pTr); 
			}else if(!pTr->left){
				pTr=pTr->right;
			}else if(!pTr->right){
				pTr=pTr->left;
			}
		}
	}else{
		printf("空树！\n");
	}
	return pTr;
}
AVLT *delAVL2(AVLT *pTr,Elementtype value){		//非递归删除
	AVLT *ptemp=pTr,*parent=ptemp;
	Stack *pStack=creatStack();
	while(ptemp){
		pushStack(pStack,ptemp);
		if(value<ptemp->value){
			ptemp=ptemp->left;
		}else if(value>ptemp->value){
			ptemp=ptemp->right;
		}else{
			ptemp=popStack(pStack);
			if(!isemptyStack(pStack)&&!ptemp->left){
				if(ptemp->value>pStack->top->value->value){
					pStack->top->value->right=ptemp->right;
				}else if(ptemp->value<pStack->top->value->value){
					pStack->top->value->left=ptemp->right;
				}
				free(ptemp);ptemp=NULL;
			}else if(!isemptyStack(pStack)&&!ptemp->right){
				if(ptemp->value>pStack->top->value->value){
					pStack->top->value->right=ptemp->left;
				}else if(ptemp->value<pStack->top->value->value){
					pStack->top->value->left=ptemp->left;
				}
				free(ptemp);ptemp=NULL;
			}else if(ptemp->left&&ptemp->right){
				Elementtype temp=maxNode(ptemp->left);
				ptemp->value=temp;
				ptemp=ptemp->left;
				value=temp;
			}else{
				free(ptemp);
				pTr=NULL;
			}	
		}
	}
	while(!isemptyStack(pStack)){
		parent=popStack(pStack);
		parent->bf=getBalance(parent);
		if(parent->bf==2||parent->bf==-2){
			parent=rotation(parent);
		}
		if(!isemptyStack(pStack)&&parent->value>pStack->top->value->value){
			pStack->top->value->right=parent;
		}else if(!isemptyStack(pStack)&&parent->value<pStack->top->value->value){
			pStack->top->value->left=parent;
		}else{
			pTr=parent;
		}	
	}
	cleanStack(&pStack);
	return pTr;
}
void cleanAVL(AVLT **pTr){						//清空树
	if(*pTr){
		cleanAVL(&(*pTr)->left);
		cleanAVL(&(*pTr)->right);
		free(*pTr);
		*pTr=NULL;
	}
}
void Preordertraversal(AVLT *pTr){				//前序递归遍历
	if(pTr){
		printf("%d ",pTr->value);
		Preordertraversal(pTr->left);
		Preordertraversal(pTr->right);
	}
}
void Inordertraversal(AVLT *pTr){				//中序递归遍历
	if(pTr){
		Inordertraversal(pTr->left);
		printf("%d ",pTr->value);
		Inordertraversal(pTr->right);
	}
}
void Postordertraversal(AVLT *pTr){				//后续递归遍历
	if(pTr){
		Postordertraversal(pTr->left);
		Postordertraversal(pTr->right);
		printf("%d ",pTr->value);
	}
}

int getHAVL(AVLT *pTr){		//递归求树高
	int h=0; 
	if(pTr){
		int hl,hr;
		hl=getHAVL(pTr->left);
		hr=getHAVL(pTr->right);
		h=max(hl,hr)+1; 
	}
	return h;
}
int getBalance(AVLT *pTr){	//求平衡因子
	if(pTr){
		return getHAVL(pTr->left)-getHAVL(pTr->right);
	}
}
int max(int a,int b){		//取大值
	return a>b?a:b;
}
Elementtype maxNode(AVLT *pTr){	//取左子树的最大值
	AVLT *ptemp=pTr->left;
	while(ptemp->right){
		ptemp=ptemp->right;
	}
	return ptemp->value;
} 
Elementtype minNode(AVLT *pTr){	//取右子树的最小值
	AVLT *ptemp=pTr->right;
	while(ptemp->left){
		ptemp=ptemp->left;
	}
	return ptemp->value;
}


AVLT *rotation(AVLT *pTr){	//旋转封装
	pTr->bf=getBalance(pTr);
	if(pTr->bf==2){
		if(pTr->left->bf==1){
			pTr=ll(pTr);
		}else{
			pTr=lr(pTr);
		}
	}
	if(pTr->bf==-2){
		if(pTr->right->bf==-1){
			pTr=rr(pTr);
		}else{
			pTr=rl(pTr);
		}
	}
	return pTr;
}
AVLT *ll(AVLT *pTr){		//左左旋转 
	AVLT *ptemp=pTr->left;
	pTr->left=ptemp->right;
	ptemp->right=pTr;
	return ptemp;
}
AVLT *rr(AVLT *pTr){		//右右旋转 
	AVLT *ptemp=pTr->right;
	pTr->right=ptemp->left;
	ptemp->left=pTr;
	return ptemp;
}
AVLT *lr(AVLT *pTr){		//左右旋转 
	pTr->left=rr(pTr->left);
	pTr=ll(pTr);
	return pTr;
}
AVLT *rl(AVLT *pTr){		//右左旋转 
	pTr->right=ll(pTr->right);
	pTr=rr(pTr);
	return pTr;
}

/*栈函数*/
Stack *creatStack(){						//创建栈 
	Stack *pStack=(Stack*)malloc(sizeof(Stack));
	pStack->bottom=pStack->top=NULL;
	return pStack;
}
int isemptyStack(Stack *pStack){			//判栈空
	return pStack->top==NULL;
} 
void pushStack(Stack *pStack,Element value){//压栈
	STNode *pNode=(STNode*)malloc(sizeof(STNode));
	pNode->value=value;
	pNode->next=NULL;
	if(isemptyStack(pStack)){
		pStack->bottom=pStack->top=pNode;
	}else{
		pNode->next=pStack->top;
		pStack->top=pNode;
	} 
} 
Element popStack(Stack *pStack){			//出栈
	Element temp=NULL;
	if(!isemptyStack(pStack)){
		temp=pStack->top->value;
		STNode *ptemp=pStack->top;
		pStack->top=pStack->top->next;
		if(pStack->top==NULL) pStack->bottom=NULL;
		free(ptemp);
	}else{
		printf("空栈！\n");
	}
	return temp;
}
void cleanStack(Stack **pStack){			//清空栈
	if(!isemptyStack(*pStack)){
		while((*pStack)->top){
			STNode *ptemp=(*pStack)->top;
			(*pStack)->top=(*pStack)->top->next;
			free(ptemp);
		}
	}else{
		free(*pStack);
		*pStack=NULL;
	}
		
}

        main函数：

#include <stdio.h>
#include <stdlib.h>
#include "avltree.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[]) {
	Elementtype value;
	scanf("%d",&value);
	AVLT *pTr=NULL;
	while(value!=-1){
		pTr=insertAVL2(pTr,value);
		scanf("%d",&value);
	}
	Preordertraversal(pTr);printf("\n");
	Inordertraversal(pTr);printf("\n");
	Postordertraversal(pTr);printf("\n");
	pTr=delAVL2(pTr,3);
	pTr=delAVL2(pTr,4);
	pTr=delAVL2(pTr,5);
	Preordertraversal(pTr);printf("\n");
	Inordertraversal(pTr);printf("\n");
	Postordertraversal(pTr);printf("\n");
	return 0;
}

诗酒伴年华
关注
专栏目录
数据结构之：平衡二叉树
bandenger的博客
05-27 358
数据结构学习之：平衡二叉树一、 平衡二叉树概述二、平衡二叉树单旋转1、右旋转2、右旋转三、平衡二叉树双旋转四、代码实现平衡二叉树的单、双旋转 一、 平衡二叉树概述 平衡二叉树(AVL树)按个人理解其实是对二叉排序树的一个升级，它其实是解决二叉排序树的一个缺陷，那么二叉排序树存在怎样的缺陷？我们知道二叉排序的查找效率是相对比较高的，不过对于下图这种二叉排序树，它的查找效率并不会提升。 平衡二叉树的出现就是为了解决这种缺陷问题，对我们的二叉树做一个平衡，以便保证它的查询效率，那怎样才能算是一棵平衡二叉树呢？我
数据结构：平衡二叉树
weixin_43624024的博客
09-24 1803
在学习平衡二叉树之前，我们需要先对二叉查找树进行一定的了解，其特征是：查找的性能取决于树的形状。因此在某些极端情况下，二叉查找树会退化为一个线性链表，查找效率的时间复杂度从O(log2n)降到了O(n)。为了规避这个缺点，引入了平衡二叉树。可以理解为平衡二叉树是基于二叉查找树的优化。 平衡二叉树在二叉查找树的基础之上增加了一个新的特性：每一个节点的左子树与右子树高度相差最多为1，这个高度的...
数据结构-平衡二叉树
echoagod的博客
07-30 545
AVL Tree
【数据结构】平衡二叉树
最新发布
Jacky_Feng的博客
01-04 3308
本文主要介绍了平衡二叉树的基本概念及基础操作（查找、平衡、插入、删除）。
广工数据结构实验——平衡二叉树
07-06
本实验“广工数据结构实验——平衡二叉树”着重探讨了一种特殊类型的数据结构，即平衡二叉树。平衡二叉树是二叉搜索树（Binary Search Tree, BST）的一个变体，它通过保持树的高度平衡来确保查找、插入和删除操作的...
广工数据结构课程设计——平衡二叉树操作的演示
07-06
广工数据结构课程设计——平衡二叉树操作的演示 内含源代码、可执行程序以及相应的说明文档 实验的功能包括： [实现提示] (1) 初始，平衡二叉树为空树，操作界面给出查找、插入和删除三种操作供选择。每种操作均要...
数据结构——平衡二叉树PTA习题（很多不会的，求大佬帮忙写题解）
流楚丶格念的博客
12-18 9901
文章目录单选题选择题题解编程题7-3 插入排序还是堆排序 (25分) 不会输入格式：输出格式：输入样例 1：输出样例 1：输入样例 2：输出样例 2：代码7-4 愿天下有情人都是失散多年的兄妹 (25分)输入格式：输出格式：输入样例：输出样例：代码 单选题 题号 题目 答案 1 AVL树是一种平衡的二叉搜索树，树中任一结点具有下列哪一特性： 左、右子树高度差的绝对值不超过1 2 C 3 在下列所示的平衡二叉树中，插入关键字48后得到一棵新平衡二叉树。在新平衡二叉树中，关
数据结构 平衡二叉树
alex1997222的博客
10-20 845
搜索树节点的不同插入次序, 将导致不同的深度和平均查找长度ASL AVL平均查找次数: avl(a) = (1 + 2x2 + 3x3 + 4x3 +5x2 + 6x1);  //平均查找长度 平衡树的概念: 平衡因子: BF(T) = 左子树的高度 - 右子树的高度 空树 或者左右两边的高度差绝对值不超过1 比如这棵树 假设7为第0层 则左边的高度为3 右边的
数据结构_平衡二叉树
ashmoc的博客
09-10 95
平衡二叉树 ( Self-Balancing Binary Search Tree 或 Height-Balancing Binary Search Tree) ：是一种二叉排序树，其中每一个节点的左子树和右子树的高度差至多等于1。它是一种高度平衡的二叉排序树。我们将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子 BF ( Balance Factor) ，所以平衡二叉树上所有的结点的平衡因子只可能是 -1 ，0 ，1。 最小不平衡子树：距离插入点最近的，且平衡因子的绝对值大于 1 的结点为根..
数据结构之平衡二叉树
rainxuanz的博客
08-22 343
数据结构之平衡二叉树 对于数据集查找，分为两种情况： 无序的顺序查找，查找效率慢，插入、删除时不用考虑其它，效率较高； 有序的查找，优化查找很多，但插入、删除时效率低； 二叉排序树 所以提出了二叉排序树的数据结构来高效的完成插入、删除和查找。 二叉排序树的定义： 二叉排序树的总结 对于左右两边平衡的二叉树，其查找效率最高，极端的单线二叉树效果最差。 平衡...
数据结构-----平衡二叉树
m0_73633088的博客
10-02 6105
前面去构建一个二叉排序树，非常简单，只需要排序就行了，那构建一个平衡二叉树不仅仅要考虑到排序问题，还要考虑到左右子树高度不大于1才行，下面我介绍一种通过旋转的方法来去构建平衡二叉树。
数据结构： 平衡二叉树
runfeel
10-27 247
一、定义 平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用算法有红黑树、AVL、Treap、伸展树等。 平衡二叉树是在二叉排序树(BST)上引入的，就是为了解决二叉排序树的不平衡性导致时间复杂度大大下降，那么AVL就保持住了...
数据结构树--＞平衡二叉树
路漫漫其修远兮
08-12 1003
平衡二叉树 平衡二叉树又叫 AVL树 前面我们介绍了二叉查找树，二叉平衡树是二叉查找树的一种，为什么会有二叉平衡树呢？这时因为二叉查找树的排序引起的，看下图。 这也是一个二叉查找树，但因为数据的原因这个二叉查找树基本成了链式结构，无法达到二叉查找树的快速查找能力，这就引入了平衡二叉树。 平衡二叉树在二叉查找树的基础上添加了平衡因子。 1. 平衡因子 平衡因子：二叉树所有节点左子树高度与右子树的高度差值的绝对值不能大于1。 只有满足这个平衡因子的二叉查找树就是一颗合格的平衡二叉树。 如图就是一个合格的平衡
广工数据结构实验：掌握平衡二叉树的实现
资源摘要信息:"广工数据结构实验——平衡二叉树" 本资源集是关于数据结构实验中的平衡二叉树部分，包含了一系列的教学和实验材料，旨在帮助学生更好地理解和掌握平衡二叉树的理论知识及其在计算机科学与技术中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值