AVL- tree

最新推荐文章于 2023-11-09 20:44:13 发布
最新推荐文章于 2023-11-09 20:44:13 发布
阅读量1.9k 收藏 1
点赞数
分类专栏： Data Structure & Algorithm DSAA 文章标签： structure algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cinmyheart/article/details/20527037
版权

AVL- tree


             In computer science, an AVL tree (Adelson-Velskii and Landis' tree, named after the inventors) is a self-balancing binary search tree. It was the first such data structure to be invented.In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, rebalancing is done to restore this property. Lookup, insertion, and deletion all take O(log n) time in both the average and worst cases, where n is the number of nodes in the tree prior to the operation. Insertions and deletions may require the tree to be rebalanced by one or moretree rotations.

The AVL tree is named after its two Soviet inventors, G. M. Adelson-Velskii and E. M. Landis, who published it in their 1962 paper "An algorithm for the organization of information".

AVL trees are often compared with red-black trees because both support the same set of operations and take O(log n) time for the basic operations. For lookup-intensive applications, AVL trees are faster than red-black trees because they are more rigidly balanced. Similar to red-black trees, AVL trees are height-balanced. Both are in general not weight-balanced nor μ-balanced for any \scriptstyle \mu\leq\tfrac12; That is, sibling nodes can have hugely differing numbers of descendants.

我的代码实现：

avl_tree.h

#ifndef _avl_TREE_H
#define _avl_TREE_H 1

//declaration for node
struct node
{
	int data;
	int height;
	int balance_factor;
	struct node* parent;
	struct node* rightchild;
	struct node* leftchild;
};

#include "avl_insert_node.h"
#include "avl_height.h"
#include "print_tree.h"
#include "single_rotation_with_left.h"
#include "single_rotation_with_right.h"
#include "double_rotation_with_left.h"
#include "double_rotation_with_right.h"

#endif

avl_tree.c 

/*****************************************************************************************
code writer : EOF
code date : 2014.03.01
e-mail: jasonleaster@gmail.com

code purpose:
			This is the main functin of this program. Just modify a avl-tree and print out 
			the data we writed in.
If something could be changed into better situation, please touch me by e-mail. Thank you!

******************************************************************************************/
#include <stdio.h>
#include "avl_tree.h"

#define ARRAY_SIZE 10

int main()
{
	int array[ARRAY_SIZE] = {2,4,23,15,98,34,66,75,41,17};
	int temp = 0;
	
	struct node* root;
	root = NULL;

	for(temp = 0;temp < ARRAY_SIZE;temp++)
	{
		root =  avl_insert_node(&root,NULL,array[temp]);
	}

	if(root == NULL)
	{
		printf("insert failed!\nProcess end!\n");
	}

	print_tree(root);

	return 0;
}

avl_height.c 

/************************************************************************
code writer :EOF
data : 2014.02.28
code purpose:
	My implementation for avl_height function
	
	This function would return current node's height and if current 
node is NULL, -1 would be returned.

	If this node is not NULL ,return height of the node,else return -1.
*************************************************************************/
#include "avl_tree.h"
#include "stdio.h"

int avl_height(struct node* p_node)
{
	if(p_node != NULL)
	{
		return p_node->height; //If current node is not NULL, we return the height of current node.
	}
	else
	{
		return -1;// If current node is NULL, we assume that the height of current node is -1.
	}
}
avl_insert_node.c 

/*****************************************************************************************
code writer : EOF
code date : 2014.03.01
e-mail: jasonleaster@gmail.com

code purpose:
		implementation of function avl_insert_node
If something could be changed into better situation, please touch me by e-mail. Thank you!

******************************************************************************************/
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include "avl_tree.h"

struct node* avl_insert_node(struct node** pp_node, struct node* p_parent,int number)
{
	if((*pp_node) == NULL)
	{
		(*pp_node) = (struct node*)malloc(sizeof(struct node));
		if((*pp_node) == NULL)
		{
			printf("malloc faild!\n");
			return 0;
		}

		//initilization for new node
		(*pp_node)->data = number;
		(*pp_node)->height = 0;
		(*pp_node)->parent = p_parent;
		(*pp_node)->rightchild = NULL;
		(*pp_node)->leftchild  = NULL;
		
	}
	else if((*pp_node)->data > number)//right_rotation
	{
		(*pp_node)->leftchild = avl_insert_node(&((*pp_node)->leftchild),(*pp_node),number);
		//Now, we have inserted a node and interrupt the balance of the tree. So, we should rebalance the tree.What we should do is rotation.
		
		(*pp_node)->height = (avl_height((*pp_node)->leftchild) > avl_height((*pp_node)->rightchild) ?\
				      avl_height((*pp_node)->leftchild) : avl_height((*pp_node)->rightchild))+1;
		
		if(abs(avl_height((*pp_node)->rightchild) - avl_height((*pp_node)->leftchild))  == 2)
		{
			if((*pp_node)->leftchild->data > number)
			{
				(*pp_node) = single_rotation_with_right(*pp_node);
			}
			else if((*pp_node)->leftchild->data < number)
			{
				(*pp_node) = double_rotation_with_right(*pp_node);
			}
		}
	}
	else if((*pp_node)->data < number)//left_rotation
	{
		
		(*pp_node)->rightchild = avl_insert_node(&((*pp_node)->rightchild),(*pp_node),number);
		
		(*pp_node)->height = (avl_height((*pp_node)->leftchild) > avl_height((*pp_node)->rightchild) ?\
				      avl_height((*pp_node)->leftchild) : avl_height((*pp_node)->rightchild))+1;
	
		if(abs(avl_height((*pp_node)->rightchild) - avl_height((*pp_node)->leftchild))  == 2)
		{
			if((*pp_node)->rightchild->data < number)
			{
				(*pp_node) = single_rotation_with_left(*pp_node);
			}
			else if((*pp_node)->rightchild->data > number)		
			{
				(*pp_node) = double_rotation_with_left(*pp_node);
			}
		}
	}
	
	return (*pp_node);
}
double_rotation_with_left.c 

/******************************************************************************
code writer : EOF
code date : 2014.03.01
e-mail : jasonleaster@gmail.com
code purpose :
		implementation of function double_rotation_with_left
If something could be changed into a situation, please touch me. Thank you!

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

#include "avl_tree.h"
#include "stdio.h"

struct node* double_rotation_with_left(struct node* p_node)
{
	struct node* temp = NULL;

	p_node = single_rotation_with_left(p_node);
	
	return  single_rotation_with_right(p_node);
}

double_rotation_with_right.c 

/************************************************************************************
code writer : EOF
code date : 2014.03.01
e-mail : jasonleaster@gmail.com
code purpose :
		implementation of function double_rotation_with_right
If something could be changed into a better situation, please touch me. Thank you!
**********************************************************************************/
#include "avl_tree.h"

struct node* double_rotation_with_right(struct node* p_node)
{

	p_node = single_rotation_with_right(p_node);

	return single_rotation_with_left(p_node);
}
single_rotation_with_left.c 

/*********************************************************************
code writer: EOF
code date: 2014.02.28
e-mail: jasonleaster@gmail.com
code purpose:
	implementation of function single_rotation_with_left

	If something could be changed into better situation, please 
touche me by e-mail

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

#include "avl_tree.h"

struct node* single_rotation_with_left(struct node* p_node)
{	
//when there are only three nodes in the tree, we make the middile node -- *p_node as the root-node.
	struct node* temp = p_node->rightchild;
	
	p_node->rightchild = temp->leftchild;
	temp->leftchild = p_node;

	p_node->height = (avl_height(p_node->rightchild) > avl_height(p_node->leftchild) ?\
		   	  avl_height(p_node->rightchild) : avl_height(p_node->leftchild))+1;
	
	temp->height = (avl_height(temp->rightchild) > avl_height(temp->leftchild) ?\
			avl_height(temp->rightchild) : avl_height(temp->leftchild))+1;

	return temp;//new root	
}
single_rotation_with_right.c 

/*********************************************************************************************
code writer : EOF
code date : 2014.03.01
e-mail : jasonleaster@gmail.com
code purpose :
		implementation of function single_rotation_with_right
If something could be changed into a better situation, please touch me. Thank you!

*********************************************************************************************/
#include "avl_tree.h"

struct node* single_rotation_with_right(struct node* p_node)
{
	struct node*  temp;
	temp = p_node->leftchild;
	p_node->leftchild = temp->rightchild;
	temp->rightchild = p_node;

	p_node->height = (avl_height(p_node->rightchild) > avl_height(p_node->leftchild) ? \
			  avl_height(p_node->rightchild) : avl_height(p_node->leftchild))+1;
	
	temp->height = (avl_height(temp->leftchild) > avl_height(temp->rightchild) ? \
			avl_height(temp->leftchild) : avl_height(temp->rightchild))+1;	
	return temp;
}

print_tree.c 
/*******************************************************************************
* code writer: EOF
* Date : 2014.02.20
* code purpose:
		This code is the definition for function -- print_tree
*e-mail:jasonleaster@gmail.com

If there somthing wrong with my code, please touch me by e-mail.Thank you!
*****************************************************************************/
#include "avl_tree.h"
#include "stdio.h"

int print_tree(struct node* p_node)// use recursion to print out the data in the binary tree
{
	// print the left side of the binary tree
	if((p_node->leftchild) != NULL)
	{
		print_tree(p_node->leftchild);
	}

	printf("%d\n",p_node->data);

	// print the right side of the binary tree
	if((p_node->rightchild) != NULL)
	{
		print_tree(p_node->rightchild);
	}
	//printf("%d\n",p_node->data); we don't need this 
}

I don't want to show all the header files. It is meaningless. But here is a simple model： 

#ifndef _SINGLE_ROTATION_WITH_LEFT_H
#define _SINGLE_ROTATION_WITH_LEFT_H 1

	extern struct node* single_rotation_with_left(struct node* p_node);

#endif
Namely, every source file has their own header file.



AVL- tree is here.





















JasonLeaster
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL-TREE.rar_avl_tree
09-21
实现了AVL_tree的插入与删除功能 及AVL_tree的线索化，并心图形的方式打印出结果
平衡二叉树（AVL tree）概述
qq_32164245的博客
05-31 2158
一、AVL tree基本概念AVL树前提是一种二叉排序树，其中每一个节点的左子树和右子树的高度差至多等于1。平衡因子BF（balance Factor）：二叉树结点的左子树深度与右子树深度的值，AVL树上所有节点的BF只能是-1、0、1，如果二叉树上有一个节点的BF的绝对值大于1，那么这个二叉树就是不平衡的。最小不平衡子树：距离插入节点最近的，且平衡因子的绝对值大于1的结点为根的子树，被称为最小不...
高度平衡二叉搜索树（AVLTree）
qq_49613557的博客
11-15 3312
高度平衡搜索二叉树（AVLTree） 目录AVL树的概念AVL树节点的定义AVL树的插入AVL树的旋转右单旋左单旋左右双旋右左双旋 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，
【数据结构】AVLTree
m0_61438674的博客
04-24 516
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2421
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
AVL树详解
最新发布
good good study, day day up!
11-09 1618
AVL树、单旋转、双旋转
AVL-Tree.zip_avl tree_tree
09-22
a sample implementation of AVL tree using c++
avl-tree.zip_tree
09-24
avl-tree for data structures
AVL-Tree.rar_tree
09-20
AVL tree implementation without pointer. Query,Insert,Erase in logN.
avl-tree.rar_avl_avl c++简单_avl tree
09-23
用c语言实验AVL树，程序需要外加txt文件用来创建被遍历图，相信看了程序后很简单。
数据结构-AVL树（平衡二叉树）
m0_61433144的博客
08-11 869
规定在插入和删除二叉搜索树的结点时，要保证任意结点的左右子树高度差的绝对值不超过1，我们将这样特殊的二叉搜索树称为AVL树（平衡二叉树）。每一个结点中有记录其左右子树高度差的平衡因子，也即平衡因子的值只可能是-1,0,1。（1如果某结点的左子树高度比右子树高度高一则平衡因子为-1，如果某结点的左子树高度比右子树高度低一则平衡因子为1，如果某结点的左子树高度与右子树高度一样则平衡因子为0）。............
平衡二叉树(AVL Tree) | 介绍及插入操作
嗅探网的博客
08-29 644
AVL 树是一种自平衡二叉搜索树 ( BST )，其中所有节点的左右子树的高度差不能超过一个。​​上面的树不是 AVL，因为 8 和 12 的左右子树的高度差大于 1。大多数 BST 操作（例如，搜索、最大值、最小值、插入、删除……等）需要时间，其中是 BST 的高度。对于，这些操作的成本可能会变成。如果我们确保在每次插入和删除后树的高度保持为，那么我们可以保证所有这些操作的上限为。AVL 树的高度始终为，其中是树中的节点数。.........
深入理解AVLTree【旋转控制平衡（单旋、双旋）】
冰果滴的博客
08-05 1069
二叉树是数据结构的重要一部分，而作为平衡二叉搜索树的AVLTree和红黑树学习起来是比较难的，但是我们需要去了解它们的思路（在学习的过程中，我们最好通过画图去更深入的理解，然后根据自己的图来完成代码实现）在学习AVLTree之前建议先去学习一下set和map（了解KV模型，键值对等）......
libubox库avl树的使用例子
liangds的专栏
12-20 2410
1. 定义一棵avl树 struct avl_tree services; 2. 初始化avl树 int avl_strcmp(const void *k1, const void *k2, void *ptr) { return strcmp(k1, k2); } avl_init(&services, avl_strcmp, false, NULL); 3. 插入结点
AVLtree（平衡二叉树）
weixin_44024891的博客
03-18 1070
      AVLtree是一个 “加了额外平衡条件” 的二叉搜索树， 相对于二叉树搜索树而言， 在设计的时候可以说是节点信息添加了平衡因子（也就是个int变量）这个概念。       我们在设计节点信息类的时候，里面的成员变量有左孩子指针、有孩子指针、存储的值（value）， ...
AVLTree(二叉平衡树)底层实现
_Y__X_的博客
05-31 318
文章目录1. AVL树的概念1.1 AVL树节点的定义1.2 AVL树的插入1.3AVL树的旋转处理1.3.1右单旋1.3.2左单旋1.3.3 左右双旋1.3.4 右左双旋1.4完整代码实现及验证 1. AVL树的概念 如果二叉搜索树的插入序列是有序的或者是接近有序，那么二叉搜索树就会退化为单支树(类似单链表)，查找元素相当于在顺序表中搜索元素,时间复杂度为O(N)。 AVLtree(Adelson Velskii Landis tree)是一个加上额外平衡条件的二叉搜索树，左右子树高度之差(简称平衡因子)
数据结构与算法4：二叉树2（平衡二叉树）
cling60的专栏
11-07 301
代码转自：http://www.cnblogs.com/skywang12345/p/3576969.html，图文并茂，此处只用于个人备份，感谢原作者skywang12345 avl_tree.h： #ifndef _AVL_TREE_H_ #define _AVL_TREE_H_ typedef int Type; typedef struct AVLTreeNode{
AVL树头文件C语言(AVLTree.h)
让阳光照进心里
10-01 2142
我的第一颗AVL树.弄了一天,虽然还没有最终测试完毕./* AVLTree.h -- AVl树头文件 */ /* 数据类型定义 */ typedef int Item ; typedef struct node { Item item ; struct node * left ; struct node * right ; int height ; } Node ; typedef Node * Position ; typedef Position Tree ;
平衡二叉树_AVLTree
happylife1527的专栏
09-03 370
#include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 /* 存储空间
学习RB-tree需要掌握哪些知识？
06-12
2. 平衡二叉树（AVL Tree）的基本概念和性质，包括AVL Tree的旋转操作、平衡因子等。 3. 红黑树（RB-Tree）的基本概念和性质，包括红黑树的定义、性质、插入和删除操作等。 4. 数据结构的基本操作，如链表、栈、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值