AVL树的C语言实现

最新推荐文章于 2023-07-01 17:02:10 发布
最新推荐文章于 2023-07-01 17:02:10 发布
阅读量587 收藏 1
点赞数
分类专栏： 算法/数据结构 文章标签： c 数据结构 AVL树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012000209/article/details/47254203
版权

AVL树是带有平衡条件的二叉查找树。之所以需要平衡是因为有的二叉查找树很糟糕，像这样

 

上一篇文章中二叉查找树的删除总是用右子树的左子树叶子来代替删除节点操作容易造成左子树比右子树深很多的情况（每次删除的都是右子树的节点）。一颗AVL树是其每个节点的左子树和右子树高度最多差1的二叉查找树。空树的高度定义为-1.因为添加了平衡条件，所以我们在编写AVL树的基本操作时需要加入是否平衡的判断，以及解决方法。

解决平衡的方法我们称之为旋转，旋转又分为以下几种情况：

 

这是单旋转，而且它的不平衡是在左边，所以是左单旋转，相应的还有右单旋转。单旋转就相当于将不平衡的三个节点中间的节点给拎了起来，而不平衡的节点就顺着重力掉了下去。单旋转只适用于不平衡节点只有左或者右子树的情况下。这种单旋转可以降低子树的深度。还有一种情况是这样

 

因为子树Y的深度过深，单旋转没有降低它的深度，旋转完之后还是产生了不平衡。这种情况就要用双旋转：双旋转是将最深的子树提升到根的高度从而来降低它的深度。而它的左右子树将相应的分给之前的节点。像这样：

 


这是左双旋转，右双旋转位置和它相反即可。因为我们已经确定某棵树在执行单一操作之前就已经是AVL树，所以造成不平衡的情况只有这些。

下面给出具体的实现代码：

 头文件：

#ifndef __AVLTREE_H
#define __AVLTREE_H

#define Max(a,b) (((a)>(b))?(a):(b)) 

struct AVLNode;
typedef struct AVLNode *AVLposition;
typedef struct AVLNode *AVLTree;
typedef int ElementType;

struct AVLNode
{
	ElementType element;
	AVLTree left;
	AVLTree right;
	int height;

};


AVLTree AVLmakeEmpty(AVLTree T);
AVLposition AVLfind(ElementType x,AVLTree T);
AVLposition AVLfindMax(AVLTree T);
AVLposition AVLfindMin(AVLTree T);
AVLTree AVLinsert(ElementType x,AVLTree T);
AVLTree AVLDelete(ElementType x,AVLTree T);
AVLTree rotate(AVLTree T);

static revolve(ElementType x,AVLTree T);	//旋转
static int getHeight(AVLposition p);
static AVLposition singleRotateWithLeft(AVLposition k2);
static AVLposition singleRotateWithRight(AVLposition k2);
static AVLposition doubleRotateWithLeft(AVLposition k3);
static AVLposition doubleRotateWithRight(AVLposition k3);
void AVLpreOrderTraverse(AVLTree Tree);	//先序遍历 根左右

#endif

实现文件： 

#include "AVLTree.h"
#include <stdlib.h>
#include <stdio.h>

AVLTree AVLmakeEmpty(AVLTree T)
{
	if(T)
	{
		AVLmakeEmpty(T->left);
		AVLmakeEmpty(T->right);
		free(T);
	}
	return NULL;
}

AVLposition AVLfind(ElementType x,AVLTree T)
{
	if(!T)
	{
		printf("cant search in a empty tree\n");
		exit(-1);
	}
	else
	{
		if(x<T->element)
			AVLfind(x,T->left);
		else if(x>T->element)
			AVLfind(x,T->right);
		else
			return T;				
	}
}

AVLposition AVLfindMax(AVLTree T)
{
	if(!T)
		return NULL;
	else if(T->right)
		AVLfindMax(T->right);
	else if(T->right==NULL)
		return T;
		
}

AVLposition AVLfindMin(AVLTree T)
{
	if(!T)
		return NULL;
	else if(T->left)
		AVLfindMin(T->left);
	else if(T->left==NULL)
		return T;
}

AVLTree AVLinsert(ElementType x,AVLTree T)
{
	if(T==NULL)
	{
		T=(struct AVLNode*)malloc(sizeof(struct AVLNode));
		if(T==NULL)
		{
			printf("out of space\n");
			exit(-1);
		}
		else
		{
			T->left=T->right=NULL;
			T->element=x;
			T->height=0;
		}
	}
	else if(x<T->element)
	{
		T->left=AVLinsert(x,T->left);
		if(getHeight(T->left)-getHeight(T->right)==2)
		{
			if(x<T->left->element)
				T=singleRotateWithLeft(T);
			else
				T=doubleRotateWithLeft(T);
		}
	}
	else if(x>T->element)
	{
		T->right=AVLinsert(x,T->right);
		if(getHeight(T->right)-getHeight(T->left)==2)
		{
			if(x>T->right->element)
				T=singleRotateWithRight(T);
			else
				T=doubleRotateWithRight(T);
		}
	}

	T->height=Max(getHeight(T->left),getHeight(T->right))+1;
	
	return T;
}

AVLTree AVLDelete(ElementType x,AVLTree T)
{
	AVLTree temp;
	if(T==NULL)
		return NULL;
	if(x==T->element)
	{
		if(T->right==NULL)
		{
			temp=T;
			T=T->left;
			free(temp);
		}
		else
		{
			temp=T->right;
			while(temp->left!=NULL)
				temp=temp->left;
		
		T->element=temp->element;
		T->right=AVLDelete(temp->element,T->right);
		T->height=Max(getHeight(T->left),getHeight(T->right))+1;
		}
		return T;
	}
	else if(x<T->element)
		T->left=AVLDelete(x,T->left);
	else
		T->right=AVLDelete(x,T->right);
	T->height=Max(getHeight(T->left),getHeight(T->right))+1;
	if(T->left!=NULL)
		T->left=rotate(T->left);
	if(T->right!=NULL)
		T->right=rotate(T->right);
	T=rotate(T);

	return T;	
}

AVLTree rotate(AVLTree T)
{
 if(getHeight(T->left) - getHeight(T->right) == 2){
        if(getHeight(T->left->left) >= getHeight(T->left->right)){
            T = singleRotateWithLeft(T);
        }
        else{
            T = doubleRotateWithLeft(T);
        }
    }
    if(getHeight(T->right) - getHeight(T->left) ==2){
        if(getHeight(T->right->right) >= getHeight(T->right->left)){
            T = singleRotateWithRight(T);
        }
        else{
            T = doubleRotateWithRight(T);
        }
    }
    return T;
}

static int getHeight(AVLposition p)
{
	if(p==NULL)
		return -1;
	else
		return p->height;
}

/*this function can be called only if k2 has a left
child,perform a rotate between a node(k2) and its left child
update heights,then return new root
*/
static AVLposition singleRotateWithLeft(AVLposition k2)
{
	AVLposition k1;
	k1=k2->left;
	k2->left=k1->right;
	k1->right=k2;

	/*更新高度为什么是这样*/
	k2->height=Max(getHeight(k2->left),getHeight(k2->right))+1;
	k1->height=Max(getHeight(k1->left),k2->height)+1;
	return k1;
}
static AVLposition singleRotateWithRight(AVLposition k2)
{
	AVLposition k1;
	k1=k2->right;
	k2->right=k1->left;
	k1->left=k2;

	/*更新高度为什么是这样*/
	k2->height=Max(getHeight(k2->left),getHeight(k2->right))+1;
	k1->height=Max(getHeight(k1->left),k2->height)+1;
	return k1;
}

/*this function can be called only if k3 has a left,child and k3's left child has
a right child,Do the left-right double rotation,update heights,then return new 
root*/

static AVLposition doubleRotateWithLeft(AVLposition k3)
{
	k3->left=singleRotateWithRight(k3->left);

	return singleRotateWithLeft(k3);
}
static AVLposition doubleRotateWithRight(AVLposition k3)
{
	k3->right=singleRotateWithLeft(k3->right);

	return singleRotateWithRight(k3);
}

static revolve(ElementType x,AVLTree T)
{
	if(getHeight(T->left)-getHeight(T->right)==2)
	{
		if(x>T->left->element)
			T=singleRotateWithLeft(T);
		else
			T=doubleRotateWithLeft(T);
	}
	if(getHeight(T->right)-getHeight(T->left)==2)
	{
		if(x>T->left->element)
			T=singleRotateWithRight(T);
		else
			T=doubleRotateWithRight(T);

	}
}
void AVLpreOrderTraverse(AVLTree Tree)
{
	if(Tree)
	{
		printf(" %d ",Tree->element);
		AVLpreOrderTraverse(Tree->left);
		AVLpreOrderTraverse(Tree->right);
	}

}

测试文件： 

#include "AVLTree.h"
#include <stdio.h>

int main()
{

	/*******************AVL树测试***************************/
	
	//AVLposition pos;
	AVLTree root=NULL;
	root=AVLinsert(3,root);
	root=AVLinsert(2,root);
	root=AVLinsert(1,root);	//旋转完后，根变了
	root=AVLinsert(4,root);
	root=AVLinsert(5,root);
	root=AVLinsert(6,root);
	root=AVLinsert(7,root);
	/*
	root=AVLinsert(16,root);
	root=AVLinsert(15,root);
	root=AVLinsert(14,root);
	root=AVLinsert(13,root);
	root=AVLinsert(12,root);
	root=AVLinsert(11,root);
	root=AVLinsert(9,root);
	root=AVLinsert(8,root);
	*/
	AVLpreOrderTraverse(root);
	root=AVLDelete(4,root);
	/*root=AVLDelete(3,root);
	root=AVLDelete(1,root);*/
	printf("\n");
	AVLpreOrderTraverse(root);
	printf("\n");

	/**********************************************/


浮生spider
关注
专栏目录
AVL树（C语言实现）
mayfly_strive的博客
02-09 2484
AVL树的相关操作，包括插入，删除，查找，调整。（C语言实现）
AVL树c语言实现
qq_37171273的博客
05-16 468
有的时候我们感觉自己写不出代码，那是因为我们从未尝试去去写。对于数据结构我学的真是很烂，感觉很难，也不想在电脑上去敲，一本数据结构和算法分析我也大约的看了一下，感觉数据结构一点意思也没有，我只学算法就行了，可是，很多算法都是对数据结构的操作，今天c语言课无聊，带了自己的数据结构看，然后一下子就打开了二叉树，二叉树中的AVL树我知道原理，却从未自己敲过，感觉太难了，到时候直接抄代码就行了，可是今天不
AVL树的实现(C语言实现)
rainxbow的专栏
02-15 976
最近恶补数据结构，不过抱着小侄女实在复习不进去。。。这才复习完树 当时对于平衡树就没有一个系统的了解  具体的感念就不贴了，仔细说一说如何调整平衡二叉树 如果插入破坏了原有的平衡，“麻烦结点”在发现者右子树的右边，因而叫 RR 插入，需要RR 旋转（右单旋） 做如下调整 “麻烦结点”在发现者左子树的左边，因而叫 LL 插入，需要LL 旋转（左单旋）
AVL树C语言实现
UniversityCD的专栏
05-02 1904
AVL树介绍 AVL树是带有平衡条件的二叉查找树。这个平衡条件必须容易保持，而且它必须保证树的高度是O(logN)。AVL树其每个节点的左子树和右子树高度最多差1(空树的高度为-1)，每个节点保留其高度信息。下图中，左边的图是AVL树，而右边的不是。 节点插入 当对一个AVL树插入节点后，只有那些从插入节点到根节点的路径上的节点的平衡可能被改变，因为这些节点的子树可能发生变化。当我们
平衡二叉树 AVL树 实现 C语言
su_1998的博客
12-16 1584
平衡树
【算法】数据结构与算法分析学习笔记——第四章AVL树C语言实现
jyyyyyy
01-10 1680
看《数据结构与算法分析》第四章时介绍到了一个AVL树的东西 对于节点删除，书上只是提了一下惰性删除，也没有给出例程，这里就试着实现非惰性删除 实现的方法同二叉查找树，找一个左子树的最大节点进行替换，递归删除，并做及时的AVL树维护
C语言数据结构之平衡二叉树（AVL树）实现方法示例
12-26
本文实例讲述了C语言数据结构之平衡二叉树（AVL树）实现方法。分享给大家供大家参考，具体如下： AVL树是每个结点的左子树和右子树的高度最多差1的二叉查找树。 要维持这个树，必须在插入和删除的时候都检测是否出现...
AVL树C语言的实现
个人公众号: 码小菜
11-09 541
AVL树(一)之 图文解析 和 C语言的实现
04-树5 Root of AVL Tree
rimianxing的博客
01-22 162
#include<stdio.h> typedef struct AVLNode *AVLTree; /* AVL树类型 */ typedef int ElementType; struct AVLNode { ElementType Data; /* 结点数据 */ AVLTree Left; /* 指向左子树 */ AVLTree Right; ...
C 语言实现 AVL 树
SauryN的博客
08-30 2022
一、平衡二叉树简介     平衡二叉树又称 AVL树，其具有如下两个性质： 必须是二叉树； 必须是一颗空树或者其左右子树的高度只差不超过 1。     平衡二叉树的实现主要是为了避免普通二叉查找树在极端情况下（全部节点只有左孩子或者全部节点只有右孩子）会像链表那样影响性能。 二、AVL树 自平衡 #include <stdio.h> #include <stdlib.h> #include <string.h> #include "AVLTree.h" #defi
平衡二叉排序树之AVL树（C语言实现）
最新发布
zhao_Tao_WA的博客
07-01 735
本文详细介绍了平衡二叉排序树中的AVL树，对失衡类型和不同失衡类型的调整方式做了细致的描写，并用C语言实现了AVL树
AVL树的基础实现c语言
Mrlie的博客
01-08 582
#include<stdio.h> #include<stdlib.h> typedef struct avltree { int data; struct avltree* left; struct avltree* right; int height; }avl; int geth(avl *p); //获取高度 int getmax(int a, int b); //获得最大值 avl* insert(avl *p, int x); //插入并调整 avl* .
AVL树 - C语言实现（五）
cherry的博客
08-27 375
1 AVL树 在二叉查找树中，为了防止某节点处出现左、右儿子树深度不平衡的情况，从而引出带有平衡条件的二叉查找树（AVL树）。 回顾树结构基本知识： 对任意的节点n，n的深度为：从根到节点n的唯一路径的长。n的高度为：从n到一片树叶的最长路径的长。 AVL树的平衡条件：每个节点的左子树和右子树的高度最多差1。 2 单旋、双旋 2.1 单旋 在插入一个节点后，只有那些从插入点到...
用C语言实现一个AVL树
weixin_35755823的博客
12-31 131
AVL树是一种平衡二叉树，它的每个节点的左右子树的高度相差不超过1。这个性质使得AVL树插入和删除操作的时间复杂度能够保持在对数级别，这与二叉搜索树相比具有较高的效率。 下面是一个用C语言实现AVL树的示例代码： ``` #include <stdio.h> #include <stdlib.h> typedef struct AVLTreeNode { int key...
C语言实现AVL树(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-22 526
C语言实现数组ArrayAVL节点定义实现以下15个接口完整实现和main测试源码 AVL节点定义 struct AVLnode { int key; struct AVLnode *left; struct AVLnode *right; int height; }; typedef struct AVLnode avlNode; 实现以下15个接口 avlNode *newNode(int key); int nodeHeight(avlNode *node); int
掌握AVL树：C语言实现自平衡二叉查找树
6. C语言实现：AVL树的实现通常需要定义节点结构体和一系列操作函数，如创建节点、插入节点、删除节点、查找节点、旋转调整等。在C语言中，这些操作需要通过结构体指针来实现对节点的操作和访问。 7. 编程实践：在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值