算法整理：查找篇-二叉排序树&&AVL树

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

目录

二叉排序树

满足一下三个性质的二叉树称为二叉排序树：

  1. 若左子树不空，左子树上所有节点的值均小于根节点的值；
  2. 若右子树不空，右子树上所有节点的值均大于根节点的值；
  3. 左子树和右子树也为二叉排序树

在这里插入图片描述
二叉排序树上的查找
在二叉排序树上进行查找非常简单，从根节点开始，进行比较，如果关键字相等，则查找成功，反之根据带查找元素与更节点元素的大小关系继续向下比较。
另外，二叉排序树上进行查找的代价与 l o g n logn logn成正比。

二叉排序树上的插入
在二叉排序树上，每次插入的节点都是新的叶子节点，所以在进行插入操作时不需要移动其他节点。
在这里插入图片描述

中序遍历二叉排序树可得到一个关键字的有序序列。也就是说一个无序序列可通过构造二叉排序树变成一个有序序列。构造树的过程即对无序序列进行排序的过程。

二叉排序树上的删除
二叉排序树上节点的删除相对来说复杂了一些，需要分成3种情况：

  1. 如果被删除节点是叶子节点，直接删除即可
  2. 如果被删除节点只有左子树或右子树，则需要使双亲结点指向被删除节点的左子树或右子树
  3. 如果被删除节点的左右子树都不为空，则有两种方式：第一种是使双亲结点指向被删除节点的左子树，并令被删除节点的右子树成为被删除节点的左子树中最大节点的右子树。第二种是用被删除节点左子树中最大的节点的值替换被删除节点的值，然后删掉左子树中最大的节点。

C++代码

bool SearchBST(BiTree* tree, int value, BiTree** parent = NULL);
BiTree* InsertBST(BiTree* tree, int value);

struct BiTree {
	int data;
	BiTree* left;
	BiTree* right;
	BiTree() :data(0), left(NULL), right(NULL) {};
	~BiTree() {
		if (left != NULL)delete left;
		if (right != NULL)delete right;
	}
};

//创建
BiTree* CreateBST(vector<int> list) {
	BiTree* tree = NULL;
	for (auto item : list) {
		tree = InsertBST(tree, item);
	}
	return tree;
}

//插入
BiTree* InsertBST(BiTree* tree, int value) {
	if (tree == NULL) {
		tree = new BiTree();
		tree->data = value;
	}
	else {
		BiTree* parent = NULL;
		BiTree** pointerToParent = &parent;
		if (!SearchBST(tree, value, pointerToParent)) {
			if (parent->data > value) {
				parent->left = new BiTree();
				parent->left->data = value;
			}
			else {
				parent->right = new BiTree();
				parent->right->data = value;
			}
		}
		else {
			cout << "节点已插入" << endl;
		}
	}
	return tree;
}

//搜索
bool SearchBST(BiTree* tree, int value, BiTree** pointerToParent) {
	if (tree == NULL)return false;
	if (tree->data == value)return true;
	if (pointerToParent != NULL)*pointerToParent = tree;
	if (tree->data > value)
	{
		return SearchBST(tree->left, value, pointerToParent);
	}
	else
	{
		return SearchBST(tree->right, value, pointerToParent);
	}
}

//删除
bool DeleteBST(BiTree** tree, int value) {
	BiTree* parent = NULL;
	BiTree** pointerToParent = tree;
	BiTree** pointerToChild;
	BiTree* node;
	if (SearchBST(*tree, value, pointerToParent)) {
		if (parent == NULL) {
			pointerToChild = tree;
			node = *tree;
		}
		else if (parent->left != NULL && parent->left->data == value) {
			pointerToChild = &(parent->left);
			node = parent->left;
		}
		else {
			pointerToChild = &(parent->right);
			node = parent->right;
		}

		if (node->left == NULL && node->right == NULL) {
			*pointerToChild = NULL;
			delete node;
		}
		else if (node->left == NULL && node->right != NULL) {
			*pointerToChild = node->right;
			node->right = NULL;
			delete node;
		}
		else if (node->left != NULL && node->right == NULL) {
			*pointerToChild = node->left;
			node->left = NULL;
			delete node;
		}
		else {
			BiTree* temp = node->left;
			pointerToChild = &(node->left);
			while (temp->right != NULL)
			{
				pointerToChild = &(temp->right);
				temp = temp->right;
			}
			node->data = temp->data;
			*pointerToChild = temp->left;
			temp->left = NULL;
			delete temp;
		}
		return true;
	}
	else {
		cout << "不存在这个节点" << endl;
		return false;
	}
}

平衡二叉树

对于相同的数据，可以构造不同的二叉排序树，而不同的二叉排序树的深度也不同，如下图所示。
在这里插入图片描述
图a是一棵比较平衡的二叉树，其平均查找长度与折半查找相同；而图b则是一棵极度不平衡的单支树，其平均查找长度与顺序查找相同。
事实上，当原数据基本有序的情况下，构造的二叉排序树会很不平衡，十分影响查找效率，因此人们提出了高度平衡的二叉树——平衡二叉树。

平衡二叉树又称为AVL树，它要么是一棵空树，要么左子树和右子树的深度差不大于1，且左子树和右子树都是平衡二叉树。

通常将平衡二叉树左子树和右子树的深度差定义为平衡因子，二叉树上所有节点的平衡因子只能为-1、0、1，如果某一个节点的平衡因子大于1，则该二叉树就是不平衡的。

下图中a为平衡二叉树，b则不是平衡二叉树，其节点内为平衡因子的值。
在这里插入图片描述

AVL树上的查找
AVL树的查找与二叉排序树排序树相同，在此不再赘述。但是由于AVL树是高度平衡的，所以它的平均查找时间复杂度为 O ( l o g n ) O(logn) O(logn) 。

AVL树上的插入
在AVL树上插入节点并不像二叉排序树上那么简单，在插入一个新的叶子节点后，AVL树的平衡可能会被打破，此时需要对树的结构进行调整。调整的步骤如下：

  • 首先找到因插入新节点而失去平衡的最小子树的根节点，将其称之为A
  • 然后根据插入节点的位置，分为四种情况调整：

    1. 单向右旋：设A的左子树的根节点为B，当新插入的节点在B的左子树上时，需要对A、B进行一次顺时针的旋转操作：在这里插入图片描述

    2. 单向左旋：设A的右子树的根节点为B，当新插入的节点在B的右子树上时，需要对A、B进行一次逆时针的旋转操作：在这里插入图片描述

    3. 双向旋转-先左后右：设A的左子树的根节点为B，B的右子树的根节点为C，如果新插入的节点在B的右子树上，则需要先对B、C进行一次逆时针旋转，然后对C、A进行一次顺时针旋转：在这里插入图片描述

    4. 双向旋转-先右后左：设A的右子树的根节点为B，B的左子树的根节点为C，如果新插入的节点在B的左子树上，则需要先对B、C进行一次順时针旋转，然后对C、A进行一次逆时针旋转：在这里插入图片描述

AVL树上的删除
在AVL树上删除节点，设被删除的节点为M，步骤如下：

  1. 首先执行上面提过的二叉排序树的删除操作
  2. 检查AVL树是否失衡，如果失衡则需要从M开始，向上移动找到第一个不平衡的节点A（即失去平衡的最小子树的根节点）
  3. 如果未找到A，说明AVL树的平衡没有改变，算法结束，否则，A的平衡因子应为2或-2。
    如果A的平衡因子为2，设B是A的左孩子，则有以下三种情况：
    (1) B的平衡因子为1，则执行类似于插入操作中单向右旋的操作，需要对A、B进行一次顺时针的旋转操作，旋转完成之后，B和A的平衡因子都为0。
    (2) B的平衡因子为0，则执行类似于插入操作中单向右旋的操作，需要对A、B进行一次顺时针的旋转操作，旋转完成之后，B的平衡因子为-1，A的平衡因子为1。
    (3) B的平衡因子为-1，C是B的右孩子，则执行类似于插入操作中先左后右旋转的操作，需要对B、C进行一次逆时针的旋转操作，然后对C、A进行一次顺时针的旋转操作，旋转完成之后，C的平衡因子为0，A、B的平衡因子由旋转前C的子树的结构决定。
    同样，如果A的平衡因子为-2，设B是A的右孩子，也有三种情况：
    (1) B的平衡因子为1，C是B的左孩子，则执行类似于插入操作中先右后左旋转的操作，需要对B、C进行一次順时针的旋转操作，然后对C、A进行一次逆时针的旋转操作，旋转完成之后，C的平衡因子为0，A、B的平衡因子由旋转前C的子树的结构决定。
    (2) B的平衡因子为0，则执行类似于插入操作中单向左旋的操作，需要对A、B进行一次逆时针的旋转操作，旋转完成之后，B的平衡因子为1，A的平衡因子为-1。
    (3) B的平衡因子为-1，则执行类似于插入操作中单向左旋的操作，需要对A、B进行一次逆时针的旋转操作，旋转完成之后，B和A的平衡因子都为0。
    （此处懒得画图了，详情参照博客AVL树的插入与删除（详解））

C++代码

//各种函数
void R_Rotate(AVLTree** p);//左旋
void L_Rotate(AVLTree** p);//右旋
void Left_Balance(AVLTree** p);//插入节点后调整 适用于LL LR型
void Right_Balance(AVLTree** p);//插入节点后调整 适用于RR RL型
bool InsertAVL(AVLTree** tree, int value, bool& taller);//插入节点
bool SearchAVL(AVLTree* tree, int value, AVLTree** pointerToParent = NULL);//查找
int getTreeHeight(AVLTree* tree);//得到树高
int getTreeHeight_R(AVLTree* tree, int height);//得到树高，递归时使用
void Right_Balance_Delete(AVLTree** p);//删除节点后调整  最小不平衡子树的平衡因子为2时使用
void Left_Balance_Delete(AVLTree** p);//删除节点后调整  最小不平衡子树的平衡因子为-2时使用
bool DeleteAVL(AVLTree** tree, int value, bool &lower);//删除节点


//AVL树结构
struct AVLTree {
	int data;
	int factor;
	AVLTree* left;
	AVLTree* right;

	AVLTree() :data(0), factor(0), left(NULL), right(NULL) {};
	~AVLTree() {
		if (left != NULL)delete left;
		if (right != NULL)delete right;
	}
};

//结构调整
void R_Rotate(AVLTree** p) {
	AVLTree* temp = (*p)->left;
	(*p)->left = temp->right;
	temp->right = (*p);
	(*p) = temp;
}

void L_Rotate(AVLTree** p) {
	AVLTree* temp = (*p)->right;
	(*p)->right = temp->left;
	temp->left = (*p);
	(*p) = temp;
}

void Left_Balance(AVLTree** p) {
	AVLTree* temp = (*p)->left;
	if (temp->factor == 1) {
		(*p)->factor = 0;
		temp->factor = 0;
		R_Rotate(p);
	}
	else if (temp->factor == -1) {
		AVLTree* temp_r = temp->right;
		if (temp_r->factor == -1) {
			(*p)->factor = 0;
			temp->factor = 1;
		}
		else if (temp_r->factor == 1) {
			(*p)->factor = -1;
			temp->factor = 0;
		}
		else {
			(*p)->factor = 0;
			temp->factor = 0;
		}
		temp_r->factor = 0;
		L_Rotate(&((*p)->left));
		R_Rotate(p);
	}
}

void Right_Balance(AVLTree** p) {
	AVLTree* temp = (*p)->right;
	if (temp->factor == -1) {
		(*p)->factor = 0;
		temp->factor = 0;
		L_Rotate(p);
	}
	else if (temp->factor == 1) {
		AVLTree* temp_l = temp->left;
		if (temp_l->factor == 1) {
			(*p)->factor = 0;
			temp->factor = -1;
		}
		else if (temp_l->factor == -1) {
			(*p)->factor = 1;
			temp->factor = 0;
		}
		else {
			(*p)->factor = 0;
			temp->factor = 0;
		}
		temp_l->factor = 0;
		R_Rotate(&((*p)->right));
		L_Rotate(p);
	}
}

void Left_Balance_Delete(AVLTree** p) {
	AVLTree* temp = (*p)->right;
	if (temp->factor == 1) {
		AVLTree* temp_r = temp->left;
		if (temp_r->factor == -1) {
			(*p)->factor = 0;
			temp->factor = 1;
		}
		else if (temp_r->factor == 1) {
			(*p)->factor = -1;
			temp->factor = 0;
		}
		else {
			(*p)->factor = 0;
			temp->factor = 0;
		}
		temp_r->factor = 0;

		R_Rotate(&((*p)->right));
		L_Rotate(p);
	}
	else if (temp->factor == 0){
		(*p)->factor = -1;
		temp->factor = 1;
		L_Rotate(p);
	}
	else {
		(*p)->factor = 0;
		temp->factor = 0;
		L_Rotate(p);
	}
}

void Right_Balance_Delete(AVLTree** p) {
	AVLTree* temp = (*p)->left;
	if (temp->factor == 1) {
		(*p)->factor = 0;
		temp->factor = 0;
		R_Rotate(p);
	}
	else if (temp->factor == 0) {
		(*p)->factor = -1;
		temp->factor = 1;
		R_Rotate(p);
	}
	else {
		AVLTree* temp_r = temp->right;
		if (temp_r->factor == -1) {
			(*p)->factor = 1;
			temp->factor = 0;
		}
		else if (temp_r->factor == 1) {
			(*p)->factor = 0;
			temp->factor = -1;
		}
		else {
			(*p)->factor = 0;
			temp->factor = 0;
		}
		temp_r->factor = 0;

		L_Rotate(&((*p)->left));
		R_Rotate(p);
	}
}

//获得树高
int getTreeHeight_R(AVLTree* tree, int height);
int getTreeHeight(AVLTree* tree) {
	int height = 0;
	if (tree == NULL) return height;
	height++;
	int temp1 = 0, temp2 = 0;
	temp1 = getTreeHeight_R(tree->left, height);
	temp2 = getTreeHeight_R(tree->right, height);
	height = temp1 > temp2 ? temp1 : temp2;
	return height;
}

int getTreeHeight_R(AVLTree* tree, int height) {
	if (tree == NULL) return height;
	height++;
	int temp1 = 0, temp2 = 0;
	temp1 = getTreeHeight_R(tree->left, height);
	temp2 = getTreeHeight_R(tree->right, height);
	height = temp1 > temp2 ? temp1 : temp2;
	return height;
}

//插入
bool InsertAVL(AVLTree** tree, int value, bool& taller) {
	if (*tree == NULL) {
		*tree = new AVLTree();
		(*tree)->data = value;
		taller = true;
	}
	else {
		if ((*tree)->data > value) {
			if (InsertAVL(&((*tree)->left), value, taller)) {
				if (taller) {
					if ((*tree)->factor == 0) {
						(*tree)->factor = 1;
						taller = true;
					}
					else if ((*tree)->factor == 1) {
						Left_Balance(tree);
						taller = false;
					}
					else {
						(*tree)->factor = 0;
						taller = false;
					}
				}
			}
			else {
				return false;
			}
		}
		else if ((*tree)->data < value)
		{
			if (InsertAVL(&((*tree)->right), value, taller)) {
				if (taller) {
					if ((*tree)->factor == 0) {
						(*tree)->factor = -1;
						taller = true;
					}
					else if ((*tree)->factor == -1) {
						Right_Balance(tree);
						taller = false;
					}
					else {
						(*tree)->factor = 0;
						taller = false;
					}
				}
			}
			else {
				return false;
			}
		}
		else {
			cout << "节点已插入" << endl;
			return false;
		}

	}
	return true;
}

//查找
bool SearchAVL(AVLTree* tree, int value, AVLTree** p
ointerToParent = NULL) {
	if (tree == NULL)return false;
	if (tree->data == value)return true;
	if (pointerToParent != NULL)*pointerToParent = tree;
	if (tree->data > value)
	{
		return SearchAVL(tree->left, value, pointerToParent);
	}
	else
	{
		return SearchAVL(tree->right, value, pointerToParent);
	}
}

//删除
bool DeleteAVL(AVLTree** tree, int value, bool &lower) {
	if (*tree == NULL) {
		cout << "未找到删除对象" << endl;
		return false;
	}
	if ((*tree)->data == value) {
		AVLTree* node;
		node = *tree;

		if (node->left == NULL && node->right == NULL) {
			*tree = NULL;
			delete node;
		}
		else if (node->left == NULL && node->right != NULL) {
			*tree = node->right;
			node->right = NULL;
			delete node;
		}
		else if (node->left != NULL && node->right == NULL) {
			*tree = node->left;
			node->left = NULL;
			delete node;
		}
		else {
			AVLTree* temp = node->left;
			AVLTree** pointToLeft = &(node->left);
			while (temp->right != NULL)
			{
				temp->factor++;
				pointToLeft = &(temp->right);
				temp = temp->right;
			}
			node->data = temp->data;
			node->factor--;
			*pointToLeft = temp->left;
			temp->left = NULL;
			delete temp;

			if (node->factor == -2) {
				Left_Balance_Delete(tree);
			}
		}
		lower = true;
		return true;
	}
	else if ((*tree)->data > value) {
		if (DeleteAVL(&((*tree)->left), value, lower)) {
			if (lower) {
				if ((*tree)->factor == 0) {
					(*tree)->factor = -1;
					lower = false;
				}
				else if ((*tree)->factor == 1) {
					(*tree)->factor = 0;
					lower = true;
				}
				else {
					(*tree)->factor = -2;
					Left_Balance_Delete(tree);
				}
			}
		}
		else {
			return false;
		}
	}
	else {
		if (DeleteAVL(&((*tree)->right), value, lower)) {
			if (lower) {
				if ((*tree)->factor == 0) {
					(*tree)->factor = 1;
					lower = false;
				}
				else if ((*tree)->factor == 1) {
					(*tree)->factor = 2;
					Right_Balance_Delete(tree);
				}
				else {
					(*tree)->factor = 0;
					lower = true;
				}
			}
		}
		else {
			return false;
		}
	}

	return true;
}

运行测试

//省略头文件
int main()
{
	AVLTree** pointToAVL;
	AVLTree* tree = NULL;
	pointToAVL = &tree;
	bool taller = false;
	bool lower = false;
	for (int i = 1; i < 30; i++) {
		InsertAVL(pointToAVL,i, taller);
	}
	TreeVisualization(tree);//打印树结构的函数，不是重点所以没有给出
	cout << endl << "删除11" << endl;
	DeleteAVL(pointToAVL, 11, lower);
	TreeVisualization(tree);
	cout << endl << "删除10" << endl;
	DeleteAVL(pointToAVL, 10, lower);
	TreeVisualization(tree);
	cout << endl << "删除12" << endl;
	DeleteAVL(pointToAVL, 12, lower);
	TreeVisualization(tree);
}

结果如下：
原始树
在这里插入图片描述
删除11
在这里插入图片描述

删除10
在这里插入图片描述
删除12
在这里插入图片描述

参考文献：

AVL树的插入与删除
AVL树的插入和删除
AVL树的插入与删除（详解）

愚者吃鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树和AVL树的比较
choudan8888的博客
08-29 1794
红黑树和AVL树都是从二叉搜索树进化而来的平衡二叉树。 AVL树的特点 一个节点的左右子数的高度差不大于1 一个节点的左右子数都是平衡二叉树 平衡二叉树满足二叉树所有的特点 AVL树的时间复杂度 一颗n个结点的AVL树的平均搜索复杂度是O(logn) 一颗n个结点的AVL树删除一个结点做平衡旋转的时间复杂度是O(logn) 一颗n个结点的AVL树插入一个结点做平衡旋转的时间复杂度是O...
二叉排序树和AVL树
qq_51340322的博客
08-28 1116
二叉排序树和AVL树 文章目录二叉排序树和AVL树一、二叉排序树1. 理论定义(1)、什么是二叉排序树(2)、简单介绍二叉排序树2. 模拟画图3. 要点分析4. 代码实现(1)、定义结构体：(2)、插入新节点：(3)、层序遍历：(4)、中序遍历：中序遍历二叉排序树可得到有序序列(5)、完整代码：二、AVL树1. 理论定义2. 模拟旋转3. 代码实现 引言：本文视频链接全部来自bilibili，因为是在bilibili大学上学qwq 一、二叉排序树 1. 理论定义 (1)、什么是二叉排序树 ​
常用数据结构-几种特殊的二叉树
袁伏彪 —— 共享，共赢
05-01 1万+
继续未尽的事情。   查找二叉树（二叉排序树） 二叉排序树(Binary Sort Tree)又称二叉查找树(Binary Search Tree)。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：         ①若它的左子树非空，则左子树上所有结点的值均小于根结点的值；         ②若它的右子树非空，则右子树上所有结点的值均大于根结点的值；
数据结构之树（3）——二叉平衡树（AVL）
二木成林
02-23 2030
AVL树 AVL树即是平衡二叉树，是一种特殊的二叉排序树。 它的左右子树都是平衡二叉树，并且左右子树的高度之差的绝对值不超过1。 注意：平衡二叉树就是一棵二叉排序树，是二叉排序树的改进，提高了查找效率。 AVL树的插入结点根二叉排序树是一样的，都是遵循左小右大的原则。 但在插入过程中，每插入一个新的结点，就需要检查新结点的插入是否使得原平衡二叉树失去平衡，如果失去平衡则需要进行平衡调整。 为了判断一棵二叉排序树是否是平衡二叉树，引进了平衡因子的概念。平衡因子是针对树中的结点来说的，一个结点的平衡
平衡二叉排序树（AVL树）
狂放不羁霸的博客
06-13 2441
平衡二叉排序树插入操作的算法思想： 1、查找插入位置，同时记录离插入位置最近的可能失衡结点A； 2、插入新结点S； 3、确定旋转点B，同时更新A的平衡因子； 4、更新B到S的路径上各结点的平衡因子（原值必为0，否则A将下移）； 5、根据A、B的平衡因子判断是否失衡以及失衡类型，并做相应处理。...
《算法》使用C/C++语言实现二叉排序树
01-02
二叉排序树（Binary Search Tree，BST）是一种特殊的二叉树，它具有以下特点： 每个结点最多有两个子结点，称为左子结点和右子结点。 对于树中的每个结点，其左子树中的所有结点的值都小于该结点的值，而右子树中的...
C#，自平衡二叉查找树（AVL Tree）的算法与源代码
最新发布
03-24
各种数据结构、算法及实用的C#源代码 C#，自平衡二叉查找树（AVL Tree）的算法与源代码 自平衡二叉查找树（AVL Tree）中任何节点的...也就是说，AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）。
二叉排序树与平衡二叉树的实现
12-26
(4)输入元素x,查找二叉排序树T,若存在含x的结点,则删该结点,并作中序遍历(执行操作2)；否则输出信息“无x”； (5)用数列L，生成平衡的二叉排序树BT:当插入新元素之后，发现当前的二叉排序树BT不是平衡的二叉排序树...
数据结构实验（单链表的基本操作,二叉树的遍历,折半查找和二叉排序树,内部排序）的实现
06-25
单链表的基本操作,二叉树的遍历,折半查找和二叉排序树,内部排序等共四个实验的实现过程。
红黑树的插入详细图解，直接拿下红黑树
08-17
红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。 它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的：...
AVL树（平衡二叉树）
蜗@牛的博客
07-08 521
一、AVL树简介 AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树（Self-Balancing Binary Search Tree,简称平衡二叉树）。 平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉排序树...
数据结构:AVL树详解(平衡二叉树)
机会是给有准备的人
11-11 2319
假如以 parent 为根的子树不平衡，即 parent 的平衡因子为2或者-2，分以下情况考虑parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR当subR的平衡因子为1时，执行左单旋当subR的平衡因子为-1时，执行右左双旋parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL当subL的平衡因子为-1是，执行右单旋当subL的平衡因子为1时，执行左右双旋。
【题集】AVL树、伸展树、红黑树、二叉查找树、替罪羊树的时间复杂度
王博（Kings）的博客
07-18 6464
目录 1. AVL树 2.伸展树 3.红黑树 4.二叉查找树 5.替罪羊树 1. AVL树 AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O(log n)。 2.伸展树 伸展树(Splay Tree)，也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找...
数据结构——二叉排序树+AVL树
75 69 69 80 32 67 79 68 73 78 71 33
09-09 2068
文章目录@[TOC]1. 定义2.基本操作 1. 定义 二叉排序树(Binary Sort Tree)，又称二叉查找树(Binary Search Tree)，其递归定义如下： 一棵空树 或者是有以下性质的二叉树 左子树不空，则左子树上所有结点的值均小于它的根节点的值 右子树不空，则右子树上所有结点的值均大于它根节点的值 左右子树也是二叉排序树 例如，下图这棵树就是一棵二叉排序树： 容...
AVL树
weixin_40920882的博客
03-17 101
平衡二叉树 平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树，且具有以下性质： 本身首先是一棵二叉搜索树 带有平衡条件：每个节点的左右子树的高度之差的绝对值（平衡因子）最多为1 也就是说，AVL树，本质上是带有平衡功能的二叉树（二叉排序树，二叉搜索树） 但AVL树也是一种特殊的二叉搜索树，在相对于数据极端情况下二叉搜索树会退化成单链表，AVL...
二叉排序树、红黑树、AVL树最简单的理解
热门推荐
linshijun33的专栏
12-04 1万+
前言[为什么写这篇]之前在知乎上看过一个提问：为什么红黑树比AVL树用的场景更为广泛，红黑树在 STL 和 Linux 都有一定的运用。而AVL树也在 Windows进程地址空间管理 中得到了使用。既然红黑树和AVL树这么厉害，就要进一步了解一下它们到底是什么。基础准备[需要懂点数据结构哦]红黑树和AVL都是来源于二叉排序树，关于二叉搜索树的相关知识本文将会对一些简单的概念和操作进行分析，更多的细节
二叉排序树与AVL树
qq_28053699的博客
04-11 1889
二叉排序树 定义：二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：  （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；  （2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；  （3）左、右子树也分别为二叉排序树； 算法思想：  查找：查找keykeykey值，由二叉排序树的定义可以知道，在进行查找操作时，可以先与根节点比较，若比根节点的值小则再与左子树的根...
看图说话之平衡二叉排序树(AVL树)
涂印的博客
10-20 7478
介绍了平衡二叉排序树的基本原理，重点介绍了AVL树的基本实现方法，并且给出了完整java代码实现
C++中排序问题中的减治法-二叉排序树算法的实现实验分析
05-19
二叉排序树，也称为二叉搜索树，是一种数据结构，它是一棵...但是，在某些情况下，由于二叉排序树的不平衡性，可能会导致算法效率下降，因此我们需要采取一些措施来保证二叉排序树的平衡性，例如AVL树、红黑树等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值