AVL树---最简单的实现

最新推荐文章于 2022-10-09 22:24:18 发布
最新推荐文章于 2022-10-09 22:24:18 发布
阅读量298 收藏 4
点赞数 1
分类专栏： 树和二叉树 文章标签： AVL树 最简单的实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40691051/article/details/102923518
版权

一、定义：

我们知道二叉查找树，有很强的排序、查找、删除、插入的能力，但是，随着插入和删除的次数变多，二叉查找树的工作的效率有可能的变得没那么好了，因为二叉查找树的工作效率依赖于树的高度，树越高效率越差(同样多的结点的情况下),因此，就需要尽可能地降低树的高度。引入AVL树的目的就是为了提高二叉查找树的效率，在每次向二叉树插入或删除结点的时候，尽可能地使二叉查找树保持平衡，平衡状态下树的高度是最低的。
维基百科:
在这里插入图片描述
上图给出了，AVL树的概念和平衡因子的概念(左子树的高度-右子树的高度)

二、分析：

首先空树是AVL树,当我们先AVL树插入或删除结点的AVL树可能会失去平衡，AVL树失去平衡的情况有以下四种:
在这里插入图片描述

1、左左（LL）不平衡情况：
在根结点的较高的左子树的左子树上插入了结点，使得根的平衡因子大于1而失去平衡，或者是在删除一个结点后，使得原本就更高的左子树的左边更高，这种情况要作右单旋(右边矮做右单旋)操作
以下假设T1、T2、T3是高度相同的满二叉树：

			 
	     y    			     y                               x
	    / \   			    / \     Right Rotation          /  \
	   x   T3 	-------->  x   T3   - - - - - - - >        T1   y 
	  / \     	insert O  / \                             /    / \
	 T1  T2   			 T1  T2                          O    T2  T3
			    		/
			  	       O

	Node *x = y->left;
	y->left = x->right;
	x->right = y;

2、右右（RR)不平衡情况：
这个和LL对称，它是原较高的右子树的右子树更高了,这种情况要进行左单旋(左边矮做左单旋)操作
以下假设T1、T2、T3是高度相同的满二叉树：

	 y                     		  x                           x                 
    / \                    		 / \             	         / \                        
   x   T3                  		T1   y     <-------        T1   y                       
  / \    \   < - - - - - - -        / \     insert O           / \                             
 T1  T2   o  Left Rotation        T2  T3                     T2  T3                                 
									    \
										 O

	Node* y = x->right;
	x->right = y->left;
	y->left = x;

3、左右(LR)不平衡情况:
原本较高的左子树(断句)的右子树高度更高了,这种情况要进行先左单,后右单的双旋操作
以下假设T1、T4高度为h、T2、T3的高度h-1：

     z    			       z                               z                           x
    / \   			      / \                            /   \                        /  \ 
   y   T4 	------->     y   T4  Left Rotate (y)        x    T4  Right Rotate(z)    y      z
  / \    	insert O    / \      - - - - - - - - ->    /  \      - - - - - - - ->  / \    / \
T1   x    			  T1   x                          y    T3                    T1  T2 T3  T4
    / \   			      / \                        / \						     /
  T2   T3 			    T2   T3                    T1   T2  						O
	  					/                              /
					   O						      O

上面图
假设在以z为根较高的左子树y的右子树x上插入一个结点O(x的左右子女上都可以)，首先y结点的平衡因子为-2,失去平衡,这里先做个左单旋，做完后(不管做不做)z的平衡因子为2,要做个右单旋。

代码类似于：

	leftRotation(y);
	rightRotation(z);

因为y是z的左子女,所以可以写成：

	z->left = leftRotation(z->left);
	return rightRotation(z);

leftRotation和rightRotation返回调整后的根结点。

4、RL不平衡情况：和LR不平衡对称
在原本较高的右子树(断句)的左子树高度更高了导致的不平衡,要先右单旋后左单旋。
以下假设T1、T4高度为h、T2、T3的高度h-1：

   z     					   z                            z                            x
  / \    					  / \                          / \                          /  \ 
T1   y   	----------> 	T1   y   Right Rotate (y)    T1   x      Left Rotate(z)   z      y
    / \  	insert O		    / \  - - - - - - - - ->     /  \   - - - - - - - ->  / \    / \
   x   T4					   x   T4                      T2   y                  T1  T2  T3  T4
  / \    					  / \                         /    /  \                    /
T2   T3  					T2   T3                      O    T3   T4                 O
							/
						   O

代码类似于：

	z->left = rightRotation(z->left);
	return leftRotation(z);

在插入或删除某个结点后，只有出现了这四种情况会导致AVL树暂时失去平衡,而相应的解决办法也给出了。因此，在代码实现的时候，每次插入删除的时候，都要从插入删除位置沿双亲位置向上回溯，检查以每个双亲为根时AVL树有没有失去平衡，失去了是哪种情况就对的就用那种方法调整。所以插入删除的时候可以用递归的方法来实现，插入和删除一个结点后就回溯到上一层，检查，然后继续回溯，直到没问题的时候。

小总结:

假设定义以自底向上第一个平衡因子为2或者-2为根的树为最小不平衡AVL树。那么它不平衡的原因就四种:
设根为root，这四种情况是：

不平衡情况说明平衡因子特点解决办法
LLroot的左子树比右子树高2，并且左子树的左子树比右子树高1或相等(插入时不会，删除时可能会)此时root的平衡因子为2，左子树的平衡因子为1或0右单旋
LRroot的左子树比右子树高2，并且左子树的右子树比左子树高1(其实相等也可以，但我把相等的情况放上面去了）此时root的平衡因子为2，左子树的平衡因子为-1先左单旋后右单旋
RRroot的右子树比左子树高2，并且右子树的右子树比左子树高1或相等(与LL同理）此时，root的平衡因子为-2，右子树的平衡因子为-1或0左单旋
RLroot的右子树比左子树高2，并且右子树的左子树比右子树高1此时，root的平衡因子为-2，root的右子树平衡因子为1先右单旋后左单旋

这个表很重要，插入和删除时就是根据这个来调整不平衡的。
左边低左单旋，右边低右单旋。这个自己理解理解图就好。

三、代码实现：

1、结点结构：

class Node
{
	public:
		int key;
		int height;
		Node *left,*right;
		Node(int _key)
		{
			key = _key;
			height = 1;
			left = right = NULL;
		}
};

2、树的高度：

int height(Node *N)
{
	if(N == NULL)
	{
		return 0;
	}
	return N->height;
}

3、max函数：返回大的值

int max(int x,int y)
{
	return x > y ? x : y;
}

4、计算以某结点为根的平衡因子：左子树的高度-右子树的高度

int getBalance(Node *root)    //获得以root为根的子树的平衡因子 
{
	if(root == NULL)
	{
		return 0;
	} 
	return height(root->left) - height(root->right);
}

5、左单旋：

Node* leftRotation(Node *x)
{//左单旋(左边矮),又称RR旋转(在较高的右子树的右子树插入结点导致失去平衡 ) 
	Node* y = x->right;
	x->right = y->left;
	y->left = x;
	
	y->height = max(height(y->left), height(y->right)) + 1;
	x->height = max(height(x->left), height(x->right)) + 1;
	
	return y;	//返回调整后的根结点 
}

6、右单旋：

Node* rightRotation(Node *y)
{ //右单旋(右边矮),又称LL旋转(在较高的左子树的左子树插入结点导致失去平衡) 
	Node *x = y->left;
	y->left = x->right;
	x->right = y;
	
	y->height = max(height(y->left), height(y->right)) + 1;
	x->height = max(height(x->left), height(x->right)) + 1;
	
	return x; 	//返回调整后的根结点 
}

7、插入：
插入完后执行以下步骤：
1）当前节点如果是插入结点的祖先之一，那么要更新当前结点的高度。
2）获取当前结点的平衡因子（左子树的高度–右子树的高度）。
3）如果平衡因子大于1，则当前结点不平衡，我们处于“左左”情况或“左右”情况。要检查是左左情况还是左右情况，请获取左子树的平衡因子。如果左子树的平衡因子大于或等于0，则为LL情况[因为大于等于0说明左子树的左子树的高度大于或等于左子树的右子树的高度,大于0时是LL情况没问题，等于0时，为方面当作LL情况来处理(LL一次左单旋就够了，LR得先左旋后右旋)]，否则为LR情况。下同
4）如果平衡因子小于-1，则当前节点不平衡，我们处于“右右”情况或“右左”情况。要检查是右右情况还是右左情况，请获取右子树的平衡因子。如果右子树的平衡因子小于或等于0，则为RR情况，否则为RL情况。

Node* insert(Node *root,int key)
{
	if(root == NULL)
	{
		return new Node(key);
	} 
	
	if(key < root->key)
	{
		root->left = insert(root->left, key); 
	}
	else if(key > root->key)
	{
		root->right = insert(root->right, key);
	}
	else 	//key == root->key不插入 
	{
		return root;
	}
	
	root->height = 1 + max(height(root->left),height(root->right));
	
	int balance = getBalance(root);		//检查平衡因子
	
	//LL情况 -->右单旋 
	if(balance > 1 && getBalance(root->left) >= 0)
	{//LL ---> 右单旋 
		return rightRotation(root); 
	} 
	
	if(balance > 1 && getBalance(root->left) < 0)
	{//LR ----->先左单旋后右单旋
		root->left = leftRotation(root->left);
		return rightRotation(root); 
	} 
	
	if(balance < -1 && getBalance(root->right) <= 0)
	{//RR---->左单旋
		return leftRotation(root);		
	}
	
	if(balance < -1 && getBalance(root->right) > 0)
	{//RL---->先右单旋后左单旋 
		root->right = rightRotation(root->right);
		return leftRotation(root);
	}
	
	return root;	//没有失去平衡 
}

8、删除：这个和二叉查找树一样，当有待删结点有两个子女时，要把它转换成删一个子女的情况(找右子树下值关键码最小的结点来代替被删(中序后继),或者左子树下关键码最大的(中序前继))。
删完后还有以下步骤：
1）当前节点如果是已删除结点的祖先之一，那么要更新当前结点的高度。
2）获取当前结点的平衡因子（左子树的高度–右子树的高度）。
3）如果平衡因子大于1，则当前结点不平衡，我们处于“左左”情况或“左右”情况。要检查是左左情况还是左右情况，请获取左子树的平衡因子。如果左子树的平衡因子大于或等于0，则为LL情况[因为大于等于0说明左子树的左子树的高度大于或等于左子树的右子树的高度,大于0时是LL情况没问题，等于0时，为方面当作LL情况来处理(LL一次左单旋就够了，LR得先左旋后右旋)]，否则为LR情况。下同
4）如果平衡因子小于-1，则当前节点不平衡，我们处于“右右”情况或“右左”情况。要检查是右右情况还是右左情况，请获取右子树的平衡因子。如果右子树的平衡因子小于或等于0，则为RR情况，否则为RL情况。

Node *minValueNode(Node *node)
{//中序右子树下第一个结点(右子树下key值最小) 
	Node *current = node;
	
	while(current->left != NULL)
	{
		current = current->left;
	}
	return current;
}

Node* deleteNode(Node* root,int key)
{
	if(root == NULL)
	{
		return root;
	} 

	if(key < root->key)
	{
		root->left = deleteNode(root->left, key);
	}
	else if(key > root->key)
	{
		root->right = deleteNode(root->right, key); 
	}
	else
	{
		if((root->left == NULL) || (root->right == NULL))
		{
			Node* temp = root->left?
						 root->left:
						 root->right; 
			if(temp == NULL)  //如果没有子女 
			{
				temp = root;	//temp 保存要删除结点 
				root = NULL;    // root 置空 
			}
			else		//有一个子女 
			{
				*root = *temp;		//把temp的值拷给root,temp代替被删 
			}
			delete temp; 
		}
		else    //如果有两个子女-->找个只有一个子女或者没有子女的子孙, 
		{		//把它的值存到当前结点,然后把这个子孙删了 
			Node *temp = minValueNode(root->right);
			
			root->key = temp->key;
			
			root->right = deleteNode(root->right,
									 temp->key);
		} 
	}
	
	//删完后root == NULL就不用检查以root为根的子树平不平衡了
	if(root == NULL)
	{
		return root;
	} 
	
	root->height = 1 + max(height(root->left),
						   height(root->right));
	
	int balance = getBalance(root);
	
	if(balance > 1 && getBalance(root->left) >= 0)
	{//LL ---> 右单旋 
		return rightRotation(root); 
	} 
	
	if(balance > 1 && getBalance(root->left) < 0)
	{//LR ----->先左单旋后右单旋
		root->left = leftRotation(root->left);
		return rightRotation(root); 
	} 
	
	if(balance < -1 && getBalance(root->right) <= 0)
	{//RR---->左单旋
		return leftRotation(root);		
	}
	
	if(balance < -1 && getBalance(root->right) > 0)
	{//RL---->先右单旋后左单旋 
		root->right = rightRotation(root->right);
		return leftRotation(root);
	}
	return root;		//返回删完后调整后的根
}

9、测试代码：

#include<iostream>
#include<vector>
#include<string>

using namespace std;

class Node
{
	public:
		int key;
		int height;
		Node *left,*right;
		Node(int _key)
		{
			key = _key;
			height = 1;
			left = right = NULL;
		}
};
int height(Node *N)
{
	if(N == NULL)
	{
		return 0;
	}
	return N->height;
}
int max(int x,int y)
{
	return (x > y )? x : y;
} 
int getBalance(Node *root)    //获得以root为根的子树的平衡因子 
{
	if(root == NULL)
	{
		return 0;
	} 
	return height(root->left) - height(root->right);
}
/*
     y                               x
    / \     Right Rotation          /  \
   x   T3   - - - - - - - >        T1   y 
  / \       < - - - - - - -            / \
 T1  T2     Left Rotation            T2  T3
*/
Node* leftRotation(Node *x)
{//左单旋(左边矮),又称RR旋转(在较高的右子树的右子树插入结点导致失去平衡 ) 
	Node* y = x->right;
	x->right = y->left;
	y->left = x;
	
	//更新x,y的高度，必须先x,后y,因为x是y的子树 
	x->height = max(height(x->left), height(x->right)) + 1;
	y->height = max(height(y->left), height(y->right)) + 1;
	
	return y;	//返回调整后的根结点 
} 
Node* rightRotation(Node *y)
{ //右单旋(右边矮),又称LL旋转(在较高的左子树的左子树插入结点导致失去平衡) 
	Node *x = y->left;
	y->left = x->right;
	x->right = y;
	
	//更新x,y的高度，必须先y,后x,因为y是x的子树 
	y->height = max(height(y->left), height(y->right)) + 1;
	x->height = max(height(x->left), height(x->right)) + 1;
	
	return x; 	//返回调整后的根结点 
} 
Node* insert(Node *root,int key)
{
	if(root == NULL)
	{
		return new Node(key);
	} 
	
	if(key < root->key)
	{
		root->left = insert(root->left, key); 
	}
	else if(key > root->key)
	{
		root->right = insert(root->right, key);
	}
	else 	//key == root->key不插入 
	{
		return root;
	}
	
	root->height = 1 + max(height(root->left),height(root->right));
	
	int balance = getBalance(root);		//检查平衡因子
	
	//LL情况 -->右单旋 
	if(balance > 1 && getBalance(root->left) >= 0)
	{//LL ---> 右单旋 
		return rightRotation(root); 
	} 
	
	if(balance > 1 && getBalance(root->left) < 0)
	{//LR ----->先左单旋后右单旋
		root->left = leftRotation(root->left);
		return rightRotation(root); 
	} 
	
	if(balance < -1 && getBalance(root->right) <= 0)
	{//RR---->左单旋
		return leftRotation(root);		
	}
	
	if(balance < -1 && getBalance(root->right) > 0)
	{//RL---->先右单旋后左单旋 
		root->right = rightRotation(root->right);
		return leftRotation(root);
	}
	
	return root;	//没有失去平衡 
}
Node *minValueNode(Node *node)
{//中序右子树下第一个结点(右子树下key值最小) 
	Node *current = node;
	
	while(current->left != NULL)
	{
		current = current->left;
	}
	return current;
}

Node* deleteNode(Node* root,int key)
{
	if(root == NULL)
	{
		return root;
	} 
	
	if(key < root->key)
	{
		root->left = deleteNode(root->left, key);
	}
	else if(key > root->key)
	{
		root->right = deleteNode(root->right, key); 
	}
	else
	{
		if((root->left == NULL) || (root->right == NULL))
		{
			Node* temp = root->left?
						 root->left:
						 root->right; 
			if(temp == NULL)  //如果没有子女 
			{
				temp = root;	//temp 保存要删除结点 
				root = NULL;    // root 置空 
			}
			else		//有一个子女 
			{
				*root = *temp;		//把temp的值拷给root,temp代替被删 
			}
			delete temp; 
		}
		else    //如果有两个子女-->找个只有一个子女或者没有子女的子孙, 
		{		//把它的值存到当前结点,然后把这个子孙删了 
			Node *temp = minValueNode(root->right);
			
			root->key = temp->key;
			
			root->right = deleteNode(root->right,
									 temp->key);
		} 
		
	}
	
	//删完后root == NULL就不用检查以root为根的子树平不平衡了
	if(root == NULL)
	{
		return root;
	} 
	
	root->height = 1 + max(height(root->left),
						   height(root->right));
	
	int balance = getBalance(root);
	
	if(balance > 1 && getBalance(root->left) >= 0)
	{//LL ---> 右单旋 
		return rightRotation(root); 
	} 
	
	if(balance > 1 && getBalance(root->left) < 0)
	{//LR ----->先左单旋后右单旋
		root->left = leftRotation(root->left);
		return rightRotation(root); 
	} 
	
	if(balance < -1 && getBalance(root->right) <= 0)
	{//RR---->左单旋
		return leftRotation(root);		
	}
	
	if(balance < -1 && getBalance(root->right) > 0)
	{//RL---->先右单旋后左单旋 
		root->right = rightRotation(root->right);
		return leftRotation(root);
	}
	
	return root;
	
}
void printBST(Node *root, int k)
{
	if(root != NULL)
	{
		printBST(root->right,k+5);
		for(int i = 0; i < k; i++)
		{
			cout<<" ";
		}
		cout<<root->key<<endl;
		printBST(root->left,k+5);
	}
}
int main()
{
	Node *root = NULL;
	root = insert(root,10); 
	root = insert(root,5); 
	root = insert(root,11); 
	root = insert(root,3); 
	root = insert(root,6);
	root = insert(root,12); 
	root = insert(root,2); 
	root = insert(root,9);  	  
	printBST(root,0);
	cout<<"------LL---------"<<endl;
	root = deleteNode(root,12);
	printBST(root,0);	
	return 0;
}

结果图：
在这里插入图片描述
特意找个删除后是root的左子树的平衡结点是0(左子树的左右子树高度相等)，当LL处理没问题。

写完了，刚了3个下午应该算搞懂了。如果哪里错了，还请各位指出哦！

KRYON!
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
平衡搜索树-AVLTree的简单实现
婉茹的博客
11-12 253
1.什么是AVL树     AVL树又称为高度平衡的二叉搜索树，它能保持二叉树的高度平衡，尽量降低二叉树的高度，减少树的平均搜索长度（近似完全二叉树）。 2.为什么叫AVL树呢？      应该是因为它是由俄罗斯数学家G.M.Adel'son-Vel'skii和E.M.Landis在1962年提出来的，所以以他们的名字命名了平衡搜索树。^*^ 3.AVL树的性质： （1）左子树和
AVL-红黑树-前缀树
最新发布
05-16
AVL树、红黑树和前缀树是数据结构与算法中的重要概念，它们在高效地存储和检索数据方面有着广泛的应用。以下是关于这三种数据结构的详细解释： 1. AVL树： AVL树是一种自平衡二叉搜索树，由G. M. Adelson-Velsky和E...
AVL树的简单实现
windyblankboy的博客
07-25 645
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis，他们在1962年的论文《An algorithm for th
AVL树简单了解
u013728021的博客
11-28 218
1.AVL树定义 在计算机科学中，AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。 查找、插入和删除在平均和最坏情况下的时间复杂度都是 O(logn)。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。 AVL树得名于它的发明者G. M. Adelson-Velsky和Evgenii Landis，他们在...
avl树重平衡的简化算法
tac_tic的博客
01-20 304
先占坑
AVL树的建立过程
qq_40836518的博客
05-10 2126
原题PTA AVL树是一种平衡的二叉搜索树，每个节点的平衡因子绝对值小于等于1。 分4种情况的旋转： RR右单旋 LL左单旋 LR旋转（通过先右旋再左旋解决） RL旋转（通过先左旋再右旋解决） 题目 An AVL tree is a self-balancing binary search tree. In an AVL tree, the heights of the two chi...
avl-tree.rar_avl_avl c++简单_avl tree
09-23
AVL树是一种自平衡二叉查找树...通过这个C语言实现的AVL树，学习者可以深入理解AVL树的工作原理和旋转操作，同时也可以掌握如何在实际编程中应用这些概念。对于想要提高数据结构知识的人来说，这是一个很好的实践项目。
AVL树 C++ 实现
03-05
在C++中实现AVL树，我们可以利用模板类来创建一个泛型的数据结构，这样就可以处理不同类型的元素。 首先，我们需要定义AVL树的节点结构。每个节点包含三个部分：键（key）存储元素值，高度（height）用于计算树的...
c代码-平衡二叉查找树 --AVL树
07-16
其中，AVL树是最早被提出的自平衡二叉查找树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL树。AVL树的关键特性是任何节点的两个子树的高度差不超过1，这保证了树的平衡性，从而提高了查询效率。...
AVL树的创建
zyl_1102179268的博客
05-22 6216
平衡二叉树下面是每个模块的代码，AVL树创建的完整版代码以上传GitHub AVLTree的创建；平衡二叉树(Balanced Binary Tree或Height-Balanced Tree)又称为AVL树。它或者是一颗空树，或者是具有下列性质的二叉树：1、它的左子树和右子树都是平衡二叉树； 2、左子树和 右子树的深度之差的绝对值不超过1； 若将二叉树上结点的**平衡因子**BF定义为该节点的右子
如何构建AVL树
qq_62940063的博客
01-23 1506
1.首先我们先定义AVL树的节点 class AVlNode<Integer>{ AVlNode(Integer theElement){ this(theElement,null,null); } AVlNode(Integer theElement,AVlNode<Integer>lt,AVlNode<Integer> rt){ element = theElement; left=lt; right=r
C++中AVL树构建详解
Artorias的博客
05-13 1191
AVL树的定义 平衡二叉树由前苏联两位数学家GM.Adelse-Velskil、E.M.Landis提出，因此一般也称作AVL树。 AVL树从本质上说仍是一颗二叉搜索树，只是在其的基础上添加了平衡要求，使得树的高度在每次插入元素后仍可以保持O（logn）的级别。 所谓的平衡操作指的是对于AVL树的任意结点来说，其左子树和右子树的高度差的绝对值不超过1，其中左子树的高度减去右子树的高度称为该结点的平衡因子。 例如，对于下面的三棵树，根结点的平衡因子分别是 -1、2、-2 基本操作函数 1.结构体 因为需要对
AVL树的实现（图文详解）
AllenSquirrel
05-19 4152
AVL树的实现
图解 AVL 树 -【数据结构】
qq_61939403的博客
10-09 727
AVL树的介绍以及插入删除实现
数据结构--AVL树（全）
weixin_48560325的博客
05-01 8801
目录 什么是AVL树？ AVL树的特点及形成原因 二叉搜索树基本概念 二叉搜索的特点 二叉搜索树的优点及缺点 改进的二叉搜索树——AVL树 AVL树的定义 AVL树的特点 结点的平衡因子balance 构建一个AVL树 构建一个AVL树的节点 什么是AVL树？ AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 AVL树的特点及形成原因 AVL树本质.
平衡二叉树(AVL树)的创建
zt的博客
02-10 5091
文章目录二叉排序树存在的问题平衡二叉树二叉树不平衡的情况单旋转双旋转左旋思路分析代码运行结果 二叉排序树存在的问题 假设有数列{1,2,3,4,5,6} 创建二叉排序树后如下图所示。下面的二叉排序树处在一些问题： 1、左子树全部为空，从形式上看更像单链表 2、查询速度明显降低不能发挥BST的优势,其查询效率还不如单链表 采用平衡二叉树可以避免这种情况的发生 平衡二叉树 平衡二叉树（AVL树）是一颗空树或者它的左右两个子树的高度差的绝对值不超过1并且左右子树也是平衡二叉树。AVL树是最先发明的自平衡二叉查找
数据结构之二叉树（十）：平衡二叉树(AVL树)的创建和使用
qq_45273552的博客
10-24 1236
平衡二叉树(AVL树)的创建和使用 引言： 前一篇我们讲过了二叉排序树的创建和使用。当给出一个数组[1,2,3,4,5,6] 时我们创建一个二叉排序树 如下： 存在问题： 左子树为空，对插入速度没有影响。 查询速度明显变慢，因为每次还需要比较左子树，其查询速度比链表还要慢。 为解决这种问题，我们本篇讲讲平衡二叉树（AVL树） 基本介绍： 平衡二叉树是在二叉排序树的基础上实现的。 1）平衡二叉树也叫平衡二叉搜索树，又成为AVL树，可以保证查询效率较高。 2）具有一下特点：它是一棵空树或者它的左右两个子树的高
AVL树简单构建和基本使用（C++)
Cute_jinx的博客
09-02 606
AVL树的原理挺复杂的，推荐一个博客，原理写得非常详细。 https://blog.csdn.net/howardemily/article/details/79543892 在这我就直接上 简化版的AVL代码吧, 希望对后来者有用。 对于LL AVLtree* opLL() { AVLtree* pa = this, *pb = left, *pc = ((left)-&gt...
由二叉树的先序序列和中序序列构建二叉树
qq_40691051的博客
10-20 3987
构造思想： 假设当前处理先序序列pre的处理区间是[a,b],中序序列in处理的区间是[c,d]。 例如： string pre = "123456789"; string in = "325416879"; pre的处理区间是[0,8],中序序列in处理的区间是[0,8] 若a<b,则以pre[a]建立二叉树的根结点，然后搜索in[c,d],找到in[i] == pre[a]的位置i...
LL型不平衡：AVL树与红黑树的插入调整策略
本文主要探讨了四种不平衡状态中的LL型在平衡搜索树，特别是AVL树和红黑树中的表现。LL型是指在插入新节点后，新节点导致了树的左侧子树过深，而右侧子树相对较浅的情况，如插入20到AVL树（如图9-7所示）导致节点50...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值