AVL树的创建与性能分析

最新推荐文章于 2024-06-25 15:09:32 发布
最新推荐文章于 2024-06-25 15:09:32 发布
阅读量129 收藏
点赞数
分类专栏： 查找 文章标签： c语言 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65251608/article/details/131266040
版权

        BST查找树是一颗有规律的二叉树，其左子树的关键字值必定比根节点小，右子树的关键字值必定比根节点大。但是BST的查找效率有时候并不优秀，因为它并不是总是平衡的。所以引出平衡的BST查找树，即AVL查找树。

        AVL查找树的性能较好，时间复杂度可以达到O(logN);

        下面给出一个具体的实例实现AVL树查找并计算其平均比较次数ASL。

        数据储存信息为Info结构体，AVL节点为AVL结构体，如下：

struct Info {
    char name[30];
    char sex[3];
    char number[12];
    char college[30];
    struct AVL* tree_node;
};
struct AVL {
    struct AVL* left;
    struct AVL* right;
    struct AVL* parent;
    Info* data;
    int height; //结点高度
};

         在创建AVL树的过程中，需要将节点一个一个插入，并判断平衡因子是否超过平衡值。所以先给出一些预备函数。

int max(int a, int b) {
    return a > b ? a : b;
}
int height(struct AVL* node) {
    if (node == NULL) return 0;
    else return node->height;
}
int get_balance(struct AVL* node) {
    if (node == NULL) return 0;
    return height(node->left) - height(node->right);
}
AVL* new_node(Info* data) 
{
    AVL* node = (AVL*)malloc(sizeof(AVL));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    node->parent = NULL;
    node->height = 1;
    return node;
}

         如果判断完平衡因子后需要调整树的结构，则会涉及到两种基本的方式，左旋还有右旋，这也是整个AVL树创建的重点和难点。

        思想如下：如果需要左旋，则先将开始调整的节点传到调整函数。先将该节点的右子树整个保存下来，然后将原来右孩子的左孩子接到该节点的右边，成为它的右孩子，然后判断该节点是否为根节点，如果是，则将其右孩子变为新的根节点，然后调整平衡因子。如果不是根节点，则调整该节点的父亲为其原来的右孩子，同时将右孩子接到该节点的原父亲下，成为其左孩子或者右孩子。然后调整平衡因子。右旋同理。

struct AVL* left_rotate(struct AVL* node) //左旋
{
    struct AVL* right_child = node->right;

    node->right = right_child->left;
    if (right_child->left != NULL)
        right_child->left->parent = node;

    right_child->parent = node->parent;

    if (node->parent == NULL) {
        // root node
    }
    else if (node == node->parent->left) {
        node->parent->left = right_child;
    } 
    else {
        node->parent->right = right_child;
    }

    right_child->left = node;
    node->parent = right_child;

    node->height = 1 + max(height(node->left), height(node->right));
    right_child->height = 1 + max(height(right_child->left), height(right_child->right));

    return right_child;
}
struct AVL* right_rotate(AVL* node) {
    AVL* left_child = node->left;
    node->left = left_child->right;

    if (left_child->right != NULL)
        left_child->right->parent = node;

    left_child->parent = node->parent;

    if (node->parent == NULL) {
        // root node
    }
    else if (node == node->parent->right) {
        node->parent->right = left_child;
    } 
    else {
        node->parent->left = left_child;
    }

    left_child->right = node;
    node->parent = left_child;

    node->height = 1 + max(height(node->left), height(node->right));
    left_child->height = 1 + max(height(left_child->left), height(left_child->right));

    return left_child;
}

AVL创建方式为一个一个节点插入创建，其插入函数也很重要。

思想如下：

        把新节点和信息都传入插入函数，基于先序遍历寻找插入位置并插入，然后更新平衡因子然后判断是否需要调整，需要如何调整。

AVL* insert(AVL* node, Info* data) {
    if (node == NULL) 
        return new_node(data);
    if (strcmp(data->number, node->data->number) < 0)
        node->left = insert(node->left, data);
    else if (strcmp(data->number, node->data->number) > 0)
        node->right = insert(node->right, data);
    else //出现相同关键字
        return node;

    node->height = 1 + max(height(node->left), height(node->right));
    int balance = get_balance(node);

    if (balance > 1 && strcmp(data->number, node->left->data->number) < 0){
        return right_rotate(node);
    }
    if (balance < -1 && strcmp(data->number, node->right->data->number) > 0) {
        return left_rotate(node);
    }
    if (balance > 1 && strcmp(data->number, node->left->data->number) > 0) {
        node->left = left_rotate(node->left);
        return right_rotate(node);
    }
    if (balance < -1 && strcmp(data->number, node->right->data->number) < 0) {
        node->right = right_rotate(node->right);
        return left_rotate(node);
    }
    return node;
}

         查找函数相对简单，基于先序递归查找。

AVL* search(AVL* node, char number[12]) 
{
    if (node == NULL)
	{
		AVLBJ_sum++;
        return NULL;
	}
    if (strcmp(number, node->data->number) == 0)
	{
		AVLBJ_sum++;
        return node;
	}
    else if (strcmp(number, node->data->number) < 0)
	{
		AVLBJ_sum++;
        return search(node->left, number);
	}
    else
	{
		AVLBJ_sum++;
        return search(node->right, number);
	}
}

计算ASL，根据定义，需要计算每一层的节点个数，基于层次遍历整棵树即可。

float AVL_asl(AVL *T)//计算并返回AVL查找成功的ASL
{
	AVL *p;
	AVL *qu[3000];   //定义队列，进行层次遍历。
	int front,rear;
	float ASL=0,n=0;
	front=rear=0;
	int count[3000]={0},i=1,j=1;  //用来记录每一层有多少个结点。
	qu[rear]=T;
	rear++;
	count[i]=1;
	i++;
	while(front!=rear)
	{
		p=qu[front];
		front=(front+1)%3000;
		if(p->left!=NULL)
		{
			qu[rear]=p->left;
			rear=(rear+1)%3000;
			count[i]++;
		}
		if(p->right!=NULL)
		{
			qu[rear]=p->right;
			rear=(rear+1)%3000;
			count[i]++;
		}
		if(j==count[i-1])
		{
			i++;
			j=1;
		}
		else
			j++;		
	}
	for(i=1;count[i]!=0;i++)
		n=n+count[i];
	for(i=1;count[i]!=0;i++)
		ASL=ASL+i*count[i];
	ASL=(1.0/n)*ASL;
	return ASL;
}

整个函数如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int AVLBJ_sum=0;
#define N 2438
struct Info {
    char name[30];
    char sex[3];
    char number[12];
    char college[30];
    struct AVL* tree_node;
};
struct AVL {
    struct AVL* left;
    struct AVL* right;
    struct AVL* parent;
    Info* data;
    int height; //结点高度
};
int max(int a, int b) {
    return a > b ? a : b;
}
int height(struct AVL* node) {
    if (node == NULL) return 0;
    else return node->height;
}
int get_balance(struct AVL* node) {
    if (node == NULL) return 0;
    return height(node->left) - height(node->right);
}
AVL* new_node(Info* data) 
{
    AVL* node = (AVL*)malloc(sizeof(AVL));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    node->parent = NULL;
    node->height = 1;
    return node;
}
struct AVL* left_rotate(struct AVL* node) //左旋
{
    struct AVL* right_child = node->right;

    node->right = right_child->left;
    if (right_child->left != NULL)
        right_child->left->parent = node;

    right_child->parent = node->parent;

    if (node->parent == NULL) {
        // root node
    }
    else if (node == node->parent->left) {
        node->parent->left = right_child;
    } 
    else {
        node->parent->right = right_child;
    }

    right_child->left = node;
    node->parent = right_child;

    node->height = 1 + max(height(node->left), height(node->right));
    right_child->height = 1 + max(height(right_child->left), height(right_child->right));

    return right_child;
}
struct AVL* right_rotate(AVL* node) {
    AVL* left_child = node->left;
    node->left = left_child->right;

    if (left_child->right != NULL)
        left_child->right->parent = node;

    left_child->parent = node->parent;

    if (node->parent == NULL) {
        // root node
    }
    else if (node == node->parent->right) {
        node->parent->right = left_child;
    } 
    else {
        node->parent->left = left_child;
    }

    left_child->right = node;
    node->parent = left_child;

    node->height = 1 + max(height(node->left), height(node->right));
    left_child->height = 1 + max(height(left_child->left), height(left_child->right));

    return left_child;
}
AVL* insert(AVL* node, Info* data) {
    if (node == NULL) 
        return new_node(data);
    if (strcmp(data->number, node->data->number) < 0)
        node->left = insert(node->left, data);
    else if (strcmp(data->number, node->data->number) > 0)
        node->right = insert(node->right, data);
    else //出现相同关键字
        return node;

    node->height = 1 + max(height(node->left), height(node->right));
    int balance = get_balance(node);

    if (balance > 1 && strcmp(data->number, node->left->data->number) < 0){
        return right_rotate(node);
    }
    if (balance < -1 && strcmp(data->number, node->right->data->number) > 0) {
        return left_rotate(node);
    }
    if (balance > 1 && strcmp(data->number, node->left->data->number) > 0) {
        node->left = left_rotate(node->left);
        return right_rotate(node);
    }
    if (balance < -1 && strcmp(data->number, node->right->data->number) < 0) {
        node->right = right_rotate(node->right);
        return left_rotate(node);
    }
    return node;
}
AVL* search(AVL* node, char number[12]) 
{
    if (node == NULL)
	{
		AVLBJ_sum++;
        return NULL;
	}
    if (strcmp(number, node->data->number) == 0)
	{
		AVLBJ_sum++;
        return node;
	}
    else if (strcmp(number, node->data->number) < 0)
	{
		AVLBJ_sum++;
        return search(node->left, number);
	}
    else
	{
		AVLBJ_sum++;
        return search(node->right, number);
	}
}
float AVL_asl(AVL *T)//计算并返回AVL查找成功的ASL
{
	AVL *p;
	AVL *qu[3000];   //定义队列，进行层次遍历。
	int front,rear;
	float ASL=0,n=0;
	front=rear=0;
	int count[3000]={0},i=1,j=1;  //用来记录每一层有多少个结点。
	qu[rear]=T;
	rear++;
	count[i]=1;
	i++;
	while(front!=rear)
	{
		p=qu[front];
		front=(front+1)%3000;
		if(p->left!=NULL)
		{
			qu[rear]=p->left;
			rear=(rear+1)%3000;
			count[i]++;
		}
		if(p->right!=NULL)
		{
			qu[rear]=p->right;
			rear=(rear+1)%3000;
			count[i]++;
		}
		if(j==count[i-1])
		{
			i++;
			j=1;
		}
		else
			j++;		
	}
	for(i=1;count[i]!=0;i++)
		n=n+count[i];
	for(i=1;count[i]!=0;i++)
		ASL=ASL+i*count[i];
	ASL=(1.0/n)*ASL;
	return ASL;
}
int main()
{
	AVL* root = NULL;
	char s[12]={'0'};      //需要查找的元素
    Info *arr,t;
	int i=0;
	float AVL_ASL;
	FILE *fp;
	arr=new Info[N];
	fp=fopen("data.txt","r");
	if(!fp)
	{
		printf("文件打开失败，程序结束！");
		exit(0);
	}
	while(!feof(fp))
	{
		fscanf(fp,"%s %s %s %s",arr[i].name,arr[i].sex,arr[i].number,arr[i].college);
		i++;
	}
	for(int i=0;i<N;i++)
	{
		root = insert(root, &arr[i]);
	}
	AVL_ASL=AVL_asl(root);
	printf("该AVL查找树的ASL为：%f\n\n",AVL_ASL);
	printf("请输入查询的电话号码：");
	scanf("%s",s);
	AVL* node1 = search(root, s);
	if (node1 == NULL) 
	{
        printf("电话号为%s的人没有找到.\n",s);
		printf("AVL共比较了%d次。\n",AVLBJ_sum);
    } 
	else 
	{
        printf("电话号为 %s 是 %s.其信息如下：\n",s, node1->data->name);
		printf("姓名\t性别\t电话号码\t学院\n");
		printf("\n%s\t%s\t%s\t%s\n",node1->data->name,node1->data->sex,node1->data->number,node1->data->college);
		printf("AVL共比较了%d次。\n",AVLBJ_sum);
    }
	fclose(fp);
	return 0;
}

运行结果如下图：

使用的数据文件为”data.txt“,具体格式见哈希查找博客：

http://t.csdn.cn/1s246icon-default.png?t=N5F7http://t.csdn.cn/1s246本文基于vs2010旗舰版编译器，使用其他编译器可能需要改动代码才可以运行，如果有错误，欢迎讨论。

 

Math-L
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
AVL树介绍与解释
2301_77564824的博客
04-12 427
AVL树是在二叉搜索树的基础上增加左右子树高度不超过1的限制，但是在修改结构的时候又因为旋转导致了效率降低，后面的红黑树就克服了这个问题，下篇文章见。
AVL树实现及其性能分析
weixin_42562387的博客
05-17 1579
AVL树的提出: 二叉搜索树虽然可以缩短查找的效率, 但如果数据有序, 或者接近有序, 二叉搜索树将退化为单支树, 查找元素相当于在顺序表中搜索元素, 效率低下. 二叉搜索树实现及其性能分析 由此,1962年G.M.Adelson-Velskii和E.M.Landis两位俄罗斯数学家提出平衡二叉搜索树的方法: 当向二叉搜索树中插入新结点后, 保证每个结点的左右子树高度之差的绝对值不超过1(超过了则对树的结点进行相应的调整), 即可降低树的高度, 从而减少平均搜索长度. 概念: 一颗AVL树或者是空树, 或者
AVL树的插入,旋转,性能
WKH
08-21 811
AVL树 向二叉搜索树中插入新节点后,保证每个节点的左右子树高度差的绝对值不超过1(对树中的节点进行调整),降低树的高度,减少平均搜索长度 AVL树具有以下特点: 左右子树都是AVL树 左右子树高度只差(平衡因子)的绝对值不超过1(1/0/-1) 如果一颗二叉搜索树是高度平衡的,就是AVL树,如果其存在n个结点,其高度可保持在O(log N),搜索时时间复杂度(O (longN)) AVL树结...
为什么选择红黑树作为底层实现
01-07 1388
为什么选择红黑树作为底层实现 红黑树是一种类平衡树, 但它不是高度的平衡树, 但平衡的效果已经很好了. 补充说明另一种 AVL 树, 我之前的博文: 《编程珠玑，字字珠玑》读书笔记完结篇——AVL树 用过 STL map 么, 你用过 linux 么(这个说大了), 他们都有红黑树的应用. 当你对搜索的效率要求较高，并且数据经常改动的情景，你可以用红黑树, 也就是 map. 至于
红黑树和AVL树的效率对比
请叫我皮皮虾的博客
09-29 1649
为什么map，set 不用AVL树作为底层实现？ 用过 STL map 么, 你用过 linux 么(这个说大了), 他们都有红黑树的应用. 当你对搜索的效率要求较高，并且数据经常改动的情景，你可以用红黑树, 也就是 map。 至于, 为什么不用 AVL 树作为底层实现, 那是因为 AVL 树是高度平衡的树, 而每一次对树的修改, 都要 rebalance, 这里的开销会比红黑树大. 红黑树插...
【 C++ 】AVL树
bit_zyx的博客
09-04 842
目录 1、底层结构 2、AVL树的概念 3、AVL树节点的定义 4、基本框架 5、AVL树的插入 6、AVL树的旋转 左单旋 右单旋 左右双旋 右左双旋 7、AVL树的验证 8、AVL树的查找 9、AVL树的删除（了解） 10、AVL树的性能 11、源码链接.........
AVL树与红黑树
波风水门的博客
05-24 164
AVL树 #include<iostream> using namespace std; template<class T> struct AVLNode { //数据 T _data; //平衡因子 int _bf; //左孩子指针 AVLNode* _left; //右孩子指针 AVLNode* _right; //父结点指针 AVLNode* _parent; //带参构造函数 AVLNode(const T& val = T()) :_p
AVL、Splay和性能分析（伪）
__hao__的博客
12-23 1253
先说明一下，这个玩意是学校数据结构课的作业。完全是赶着ddl写完的，所以后面我都有点不知道自己在写什么。gprof也不太会，瞎弄的。主要放这里做个归档，如果对大家有帮助就更好了。当然，有问题也欢迎大家批评指正。 平衡二叉搜索树性能分析 问题描述 在AVL、Splay和红黑树三种平衡二叉搜索树中至少实现两种，需要支持以下操作：元素插入、删除和查询。在题目中，所有数据均为非负整数。查询时给出一非负整数xxx，需要求出树中满足y≤xy\le xy≤x的最大整数yyy；若树中不存在满足条件的yyy，查询返回-1.
基于AVL树表示的集合ADT实现与应用1
08-03
国内外的研究主要集中在改进AVL树的平衡策略、优化旋转操作以及在特定应用中的性能分析。 4. 系统需求与设计 实现基于AVL树的集合ADT，需要满足的基本功能包括元素的添加、删除、查找以及遍历。在设计时，需要考虑...
数据结构实验--基于二叉排序树的商品查询系统
10-16
为了解决这个问题，可以使用自平衡二叉搜索树，如AVL树或红黑树。但在这个实验中，可能没有涉及自平衡二叉树，而是专注于基础的二叉排序树操作。 在调试过程中，需要对各种操作进行测试，确保它们都能正确地在二叉...
数据结构二叉排序树.doc
09-25
二叉排序树（Binary Sort Tree）是一种特殊类型的二叉树，它主要用于快速查找、插入和...然而，如果插入操作导致树严重倾斜，性能可能会退化到O(n)，这时可以考虑使用更高级的数据结构，如AVL树或红黑树来保持平衡。
C语言力扣刷题6——旋转链表——[快慢双指针法]
最新发布
why1249777255的博客
06-25 434
C语言，双指针，旋转链表，中等难度。
C++ 内存分配可视化
一个大佬的博客
06-24 655
注：宽度表示生存时间(黑色表示泄漏)，高度表示内存占用大小，颜色表示每次调用地址。
什么野指针（c++）
qq_35374791的博客
06-24 6815
野指针（Wild Pointer）是指向不确定位置或者非法地址的指针。当一个指针指向的内存被释放后，如果没有将其设置为NULL，那么这个指针就变成了野指针。使用野指针会导致未定义行为，可能引发程序崩溃或数据损坏。
C++ TheadPool 线程池实现
GodJhin的博客
06-21 840
此情况发生情形3且设置了任务缓冲队列大小后面，主程序添加第N个任务，添加后发现池子中的线程用完了，任务缓冲队列也满了，于是进入等待状态、等待任务缓冲队列中的任务腾空通知。此情况基于情形1，所有工作线程已处在等待状态，主线程开始添加三个任务，添加后通知(notif())唤醒线程池中的线程开始取(take())任务执行. 此时的任务缓冲队列还是空。此情况发生情形2后面，所有工作线程都在工作中，主线程开始添加第四个任务，添加后发现现在线程池中的线程用完了，于是存入任务缓冲队列。
makefile文件编写（C）
baidu_34971492的博客
06-24 223
这个Makefile定义了如何编译和链接你的程序。CC变量指定了编译器（这里是gcc），CFLAGS变量包含了编译器的标志，比如警告选项和调试信息，LDFLAGS变量用于链接时的选项。运行Makefile：在命令行中运行make命令，Makefile会根据其规则自动编译和链接你的程序。
【华为OD机试】 硬件产品销售方案（C++/Java/Python）
dvlinker的技术专栏
06-24 35
【华为OD机试】 硬件产品销售方案（C++/Java/Python）
0621# C++八股 1.成员初始化列表的概念？以及为什么使用它会快一点？2.重写Override和重载Overload区别
qq_52784762的博客
06-21 701
成员初始化列表：用于在构造函数体执行之前初始化成员变量，提供更高效的初始化方式。直接初始化 vs. 赋值初始化：直接初始化避免了多余的默认构造和赋值操作，提高了性能。使用场景：特别适用于必须初始化的成员变量（如常量和引用），以及需要提高效率的情况。
第九章集合答案1.doc
12-11
4. AVL树的节点数量：第54题介绍了AVL树的特性，深度为m的AVL树最少节点数可以通过递归公式得出，与斐波那契数列有关。满二叉树的节点数达到最大值2m-1。 5. 树的高度与平衡：第55题强调了插入操作对树高度的影响，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Math-L

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

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

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

打赏作者

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

抵扣说明：

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

余额充值