【C++】AVL树的插入与删除

原创 已于 2024-11-07 14:18:57 修改 · 1.6k 阅读 · 17 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#c++ #数据结构 #算法
于 2024-10-31 14:57:38 首次发布

系列文章目录

第二篇 数据结构学习之AVL树的插入与删除

文章目录

前言

AVL 树是一种高度平衡的二叉搜索树，以发明者 Adelson-Velsky 和 Landis 的名字命名。它通过在插入和删除操作后调整树的平衡，确保任意节点的左右子树高度差不超过 1。与红黑树类似，AVL 树的查找、插入和删除的时间复杂度为O(logn)，但 AVL 树更加严格地平衡，因此通常在查找操作上表现更好。本文将介绍 AVL 树的特点，并通过 C++ 代码实现插入、删除、平衡和旋转操作。

一、AVL 树的基本概念

AVL 树是一种自平衡的二叉搜索树，每个节点的左右子树的高度差（即平衡因子）不超过 1。AVL 树的插入和删除操作会自动调整树的平衡性，确保查找操作的时间复杂度始终为 O(logn)。

AVL 树的主要特点：
1，每个节点的左右子树的高度差不超过 1。
2，每次插入或删除节点后，如果树不平衡，则通过旋转操作进行调整，恢复平衡。
3，AVL 树中的平衡因子定义为：
平衡因子 = 左子树高度 - 右子树高度

  • 平衡因子为 1、0 或 -1 的节点被认为是平衡的。
  • 平衡因子超过 1 或 -1 的节点需要进行旋转调整。

二、参考视频链接

AVL树

三、代码实现

1. 定义节点类

在 C++ 中，我们首先定义一个节点类，包括颜色、值、左孩子、右孩子和父节点指针。

template<class K,class V>
struct AVLTreeNode
{
	typedef AVLTreeNode<K, V> Node;
	Node* _left;
	Node* _right;
	Node* _parent;
	pair<K, V> _kv;
	int _bf;//平衡因子,右树高度－左树高度

	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _bf(0)
	{

	}
};
template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
	Node* _root = nullptr;
};

2.旋转方法

包括左旋，右旋，左右双旋，右左双旋

//左旋
Node* RotateL(Node* parent)
{
	Node* Rnode = parent->_right;
	Node* RLnode = Rnode->_left;

	parent->_right = RLnode;
	//RLnode可能为空
	if (RLnode) RLnode->_parent = parent;
	Rnode->_left = parent;
	Node* ppnode = parent->_parent;
	parent->_parent = Rnode;

	if (parent == _root)
	{
		_root = Rnode;
	}
	else if (parent == ppnode->_left)
	{
		ppnode->_left = Rnode;
	}
	else
	{
		ppnode->_right = Rnode;
	}
	Rnode->_parent = ppnode;
	Rnode->_bf = 0;
	parent->_bf = 0;
	return Rnode;
}

//右旋
Node* RotateR(Node* parent)
{
	Node* Lnode = parent->_left;
	Node* LRnode = Lnode->_right;

	parent->_left = LRnode;
	//LRnode可能为空
	if (LRnode) LRnode->_parent = parent;
	Lnode->_right = parent;
	Node* ppnode = parent->_parent;
	parent->_parent = Lnode;

	if (parent == _root)
	{
		_root = Lnode;
	}
	else if (parent == ppnode->_left)
	{
		ppnode->_left = Lnode;
	}
	else
	{
		ppnode->_right = Lnode;
	}
	Lnode->_parent = ppnode;
	parent->_bf = 0;
	Lnode->_bf = 0;
	return Lnode;
}

//左右双旋
Node* RotateLR(Node* parent)
{
	Node* Lnode = parent->_left;
	Node* LRnode = Lnode->_right;
	int bf = LRnode->_bf;
	RotateL(Lnode);
	RotateR(parent); 

	LRnode->_bf = 0;
	if (bf == 1)
	{
		parent->_bf = 0;
		Lnode->_bf = -1;
	}
	else if (bf == -1)
	{
		parent->_bf = 1;
		Lnode->_bf = 0;
	}

	//该节点就是新增结点
	else if (bf == 0)
	{
		parent->_bf = 0;
		Lnode->_bf = 0;
	}
	else
	{
		//树出现问题
		assert(false);
	}
	return LRnode;
}

//右左双旋
Node* RotateRL(Node* parent)
{
	Node* Rnode = parent->_right;
	Node* RLnode = Rnode->_left;
	int bf = RLnode->_bf;
	RotateR(Rnode);
	RotateL(parent);
	RLnode->_bf = 0;
	if (bf == -1)
	{
		Rnode->_bf = 1;
		parent->_bf = 0;
	}
	else if (bf == 1)
	{
		Rnode->_bf = 0;
		parent->_bf = -1;
	}

	//该节点就是新增结点
	else if (bf == 0)
	{
		Rnode->_bf = 0;
		parent->_bf = 0;
	}
	else
	{
		//树出现问题
		assert(false);
	}
	return RLnode;
}

3.AVL树插入操作

在 AVL 树中插入节点后，需要检查是否打破了平衡。根据节点的平衡因子进行不同类型的旋转调整。

bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
	{
		_root = new Node(kv);
		return true;
	}
	Node* tmp = _root;
	Node* parent = nullptr;
	while (tmp)
	{
		if (tmp->_kv.first < kv.first)
		{
			parent = tmp;
			tmp = tmp->_right;
		}
		else if (tmp->_kv.first > kv.first)
		{
			parent = tmp;
			tmp = tmp->_left;
		}
		else
		{
			return false;
		}
	}
	tmp = new Node(kv);
	if (parent->_kv.first < kv.first)
	{
		parent->_right = tmp;
	}
	else
	{
		parent->_left = tmp;
	}
	tmp->_parent = parent;
	while (parent)
	{
		if (tmp == parent->_right)
		{
			parent->_bf++;
		}
		else
		{
			parent->_bf--;
		}
		if (parent->_bf == 0)
		{
			break;
		}
		else if (parent->_bf == 1 || parent->_bf == -1)
		{
			tmp = parent;
			parent = parent->_parent;
			
		}
		else if (parent->_bf == 2 || parent->_bf == -2)
		{
			//旋转调节
			if (parent->_bf == 2 && tmp->_bf == 1)
			{
				//左单旋
				RotateL(parent);
			}
			else if (parent->_bf == -2 && tmp->_bf == -1)
			{
				//右单旋
				RotateR(parent);
			}
			else if (parent->_bf == 2 && tmp->_bf == -1)
			{
				//右左双旋
				RotateRL(parent);
			}
			else if (parent->_bf == -2 && tmp->_bf == 1)
			{
				//左右双旋
				RotateLR(parent);
			}
			else
			{
				//树出现问题
				assert(false);
			}
			break;
		}
		else
		{
			//树已经是错误的
			assert(false);
			return false;
		}
	}
	return true;
}

4.AVL树删除操作

AVL 树的删除操作和插入类似，在删除节点后需要调整树的平衡，以确保 AVL 树的平衡性。

bool Erase(const K& key)
{
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (cur->_kv.first < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_kv.first > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			Node* del = cur;
			//找到了
			//左子树为空
			if (cur->_left == nullptr)
			{
				//根节点
				if (cur == _root)
				{
					_root = cur->_right;
				}
				else if (parent->_left == cur)
				{
					parent->_bf++;
					parent->_left = cur->_right;
				}
				else
				{
					parent->_bf--;
					parent->_right = cur->_right;
				}
				if (cur->_right) cur->_right->_parent = parent;
			}
			//右为空
			else if (cur->_right == nullptr)
			{
				if (cur == _root)
				{
					_root = cur->_left;
				}
				else if (parent->_left == cur)
				{
					parent->_bf++;
					parent->_left = cur->_left;
				}
				else
				{
					parent->_bf--;
					parent->_right = cur->_left;
				}
				if (cur->_left) cur->_left->_parent = parent;
			}
			//左右都不为空
			else
			{
				//替换法删除,替换右子树最左节点
				cur = cur->_right;
				parent = del;
				while (cur->_left)
				{
					parent = cur;
					cur = cur->_left;
				}
				del->_kv = cur->_kv;
				if (parent->_left == cur)
				{
					parent->_bf++;
					parent->_left = cur->_right;
				}
				else
				{
					parent->_bf--;
					parent->_right = cur->_right;
				}
				if (cur->_right) cur->_right->_parent = parent;
			}
			del = cur;
			//调节平衡因子
			while (parent)//最多更新到根
			{

				if (parent->_bf == 1 || parent->_bf == -1)
				{
					break;
				}

				else if (parent->_bf == 2 || parent->_bf == -2)
				{
					//右旋
					if (parent->_bf == -2 && parent->_left->_bf == -1)
					{
						parent = RotateR(parent);//旋转之后,之前的Parent会变成子,所以旋转添加一个返回值,为实际新的parent

					}

					//左旋
					else if (parent->_bf == 2 && parent->_right->_bf == 1)
					{
						parent = RotateL(parent);//旋转之后,之前的Parent会变成子,所以旋转添加一个返回值,为实际新的parent

					}

					//左右双旋
					else if (parent->_bf == -2 && parent->_left->_bf == 1)
					{
						parent = RotateLR(parent);//旋转之后,之前的Parent会变成子,所以旋转添加一个返回值,为实际新的parent

					}

					//右左双旋
					else if (parent->_bf == 2 && parent->_right->_bf == -1)
					{
						parent = RotateRL(parent);//旋转之后,之前的Parent会变成子,所以旋转添加一个返回值,为实际新的parent

					}

					//左旋
					else if (parent->_bf == 2 && parent->_right->_bf == 0)
					{

						Node* Tparent = parent;
						Node* Rnode = parent->_right;
						parent = RotateL(parent);//旋转之后,之前的Parent会变成子,所以旋转添加一个返回值,为实际新的parent
						Tparent->_bf = 1;
						Rnode->_bf = -1;
						
					}
					//右旋
					else if (parent->_bf == -2 && parent->_left->_bf == 0)
					{
						Node* Tparent = parent;
						Node* Lnode = parent->_left;
						parent = RotateR(parent);//旋转之后,之前的Parent会变成子,所以旋转添加一个返回值,为实际新的parent
						Tparent->_bf = -1;
						Lnode->_bf = 1;
						
					}
					else
					{
						assert(false);
					}
				}

				if (parent->_bf == 0)
				{
					cur = parent;
					parent = parent->_parent;
					if (parent && parent->_left == cur)
					{
						parent->_bf++;
					}
					else if (parent && parent->_right == cur)
					{
						parent->_bf--;
					}

				}


			}
			delete del;
			return true;
		}
		
		
	}
	return false;
}

四，总体代码

#pragma once
#include <assert.h>
#include <vector>
//旋转情况
//右树右边插入,parent的_bf为2,发生左单旋
//右树左边插入,parent的_bf为2,发生右左双旋
//左树左边插入,parent的_bf为2,发生右单旋
//左树右边插入,parent的_bf为2,发生左右双旋
//旋转后仍然是搜索树,从不平衡到平衡,高度减少

template<class K,class V>
struct AVLTreeNode
{
	typedef AVLTreeNode<K, V> Node;
	Node* _left;
	Node* _right;
	Node* _parent;
	pair<K, V> _kv;
	int _bf;//平衡因子,右树高度－左树高度

	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _bf(0)
	{

	}
};

template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		Node* tmp = _root;
		Node* parent = nullptr;
		while (tmp)
		{
			if (tmp->_kv.first < kv.first)
			{
				parent = tmp;
				tmp = tmp->_right;
			}
			else if (tmp->_kv.first > kv.first)
			{
				parent = tmp;
				tmp = tmp->_left;
			}
			else
			{
				return false;
			}
		}
		tmp = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = tmp;
		}
		else
		{
			parent->_left = tmp;
		}
		tmp->_parent = parent;
		while (parent)
		{
			if (tmp == parent->_right)
			{
				parent->_bf++;
			}
			else
			{
				parent->_bf--;
			}
			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				tmp = parent;
				parent = parent->_parent;
				
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//旋转调节
				if (parent->_bf == 2 && tmp->_bf == 1)
				{
					//左单旋
					RotateL(parent);
				}
				else if (parent->_bf == -2 && tmp->_bf == -1)
				{
					//右单旋
					RotateR(parent);
				}
				else if (parent->_bf == 2 && tmp->_bf == -1)
				{
					//右左双旋
					RotateRL(parent);
				}
				else if (parent->_bf == -2 && tmp->_bf == 1)
				{
					//左右双旋
					RotateLR(parent);
				}
				else
				{
					//树出现问题
					assert(false);
				}
				break;
			}
			else
			{
				//树已经是错误的
				assert(false);
				return false;
			}
		}
		return true;
	}
	void InOrder()
	{
		_InOrder(_root);
	}

	int Height()
	{
		return _Height(_root);
	}

	bool IsBanlance()
	{
		int count = 0;
		return _IsBanlance(_root,count);
	}

	int size()
	{
		int num = 0;
		_size(_root,num);
		return num;
	}


	bool Erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				Node* del = cur;
				//找到了
				//左子树为空
				if (cur->_left == nullptr)
				{
					//根节点
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else if (parent->_left == cur)
					{
						parent->_bf++;
						parent->_left = cur->_right;
					}
					else
					{
						parent->_bf--;
						parent->_right = cur->_right;
					}
					if (cur->_right) cur->_right->_parent = parent;
				}
				//右为空
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else if (parent->_left == cur)
					{
						parent->_bf++;
						parent->_left = cur->_left;
					}
					else
					{
						parent->_bf--;
						parent->_right = cur->_left;
					}
					if (cur->_left) cur->_left->_parent = parent;
				}
				//左右都不为空
				else
				{
					//替换法删除,替换右子树最左节点
					cur = cur->_right;
					parent = del;
					while (cur->_left)
					{
						parent = cur;
						cur = cur->_left;
					}
					del->_kv = cur->_kv;
					if (parent->_left == cur)
					{
						parent->_bf++;
						parent->_left = cur->_right;
					}
					else
					{
						parent->_bf--;
						parent->_right = cur->_right;
					}
					if (cur->_right) cur->_right->_parent = parent;
				}
				del = cur;
				//调节平衡因子
				while (parent)//最多更新到根
				{

					if (parent->_bf == 1 || parent->_bf == -1)
					{
						break;
					}

					else if (parent->_bf == 2 || parent->_bf == -2)
					{
						//右旋
						if (parent->_bf == -2 && parent->_left->_bf == -1)
						{
							parent = RotateR(parent);//旋转之后,之前的Parent会变成子,所以旋转添加一个返回值,为实际新的parent

						}

						//左旋
						else if (parent->_bf == 2 && parent->_right->_bf == 1)
						{
							parent = RotateL(parent);//旋转之后,之前的Parent会变成子,所以旋转添加一个返回值,为实际新的parent

						}

						//左右双旋
						else if (parent->_bf == -2 && parent->_left->_bf == 1)
						{
							parent = RotateLR(parent);//旋转之后,之前的Parent会变成子,所以旋转添加一个返回值,为实际新的parent

						}

						//右左双旋
						else if (parent->_bf == 2 && parent->_right->_bf == -1)
						{
							parent = RotateRL(parent);//旋转之后,之前的Parent会变成子,所以旋转添加一个返回值,为实际新的parent

						}

						//左旋
						else if (parent->_bf == 2 && parent->_right->_bf == 0)
						{

							Node* Tparent = parent;
							Node* Rnode = parent->_right;
							parent = RotateL(parent);//旋转之后,之前的Parent会变成子,所以旋转添加一个返回值,为实际新的parent
							Tparent->_bf = 1;
							Rnode->_bf = -1;
							
						}
						//右旋
						else if (parent->_bf == -2 && parent->_left->_bf == 0)
						{
							Node* Tparent = parent;
							Node* Lnode = parent->_left;
							parent = RotateR(parent);//旋转之后,之前的Parent会变成子,所以旋转添加一个返回值,为实际新的parent
							Tparent->_bf = -1;
							Lnode->_bf = 1;
							
						}
						else
						{
							assert(false);
						}
					}

					if (parent->_bf == 0)
					{
						cur = parent;
						parent = parent->_parent;
						if (parent && parent->_left == cur)
						{
							parent->_bf++;
						}
						else if (parent && parent->_right == cur)
						{
							parent->_bf--;
						}

					}


				}
				delete del;
				return true;
			}
			
			
		}
		return false;
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}

private:

	void _size(const Node* root, int& num)
	{
		if (root == nullptr)
		{
			return ;
		}
		_size(root->_left, num);
		++num;
		_size(root->_right, num);
	}

	bool _IsBanlance(Node* root,int& count)
	{
		if (root == nullptr)
		{
			count = 0;
			return true;
		}
		int left = 0, right = 0;
		if (!_IsBanlance(root->_left,left) || !_IsBanlance(root->_right,right))
		{
			return false;
		}
		if (abs(right - left) >= 2)
		{
			cout << "平衡因子绝对值>=2" << endl;
			return false;
		}
		else if (right - left != root->_bf)
		{
			cout << "平衡因子异常" << endl;
			return false;
		}
		count = left > right ? left + 1 : right + 1;
		return true;
		
	}

	int _Height(const Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}

		int left = _Height(root->_left);
		int right = _Height(root->_right);
		return left > right ? left + 1 : right + 1;
	}

	void _InOrder(const Node* node)
	{
		if (node == nullptr)
		{
			return;
		}
		_InOrder(node->_left);
		cout << node->_kv.first << ":" << node->_kv.second << endl;
		_InOrder(node->_right);
	}

	//左旋
	Node* RotateL(Node* parent)
	{
		Node* Rnode = parent->_right;
		Node* RLnode = Rnode->_left;

		parent->_right = RLnode;
		//RLnode可能为空
		if (RLnode) RLnode->_parent = parent;
		Rnode->_left = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = Rnode;

		if (parent == _root)
		{
			_root = Rnode;
		}
		else if (parent == ppnode->_left)
		{
			ppnode->_left = Rnode;
		}
		else
		{
			ppnode->_right = Rnode;
		}
		Rnode->_parent = ppnode;
		Rnode->_bf = 0;
		parent->_bf = 0;
		return Rnode;
	}

	//右旋
	Node* RotateR(Node* parent)
	{
		Node* Lnode = parent->_left;
		Node* LRnode = Lnode->_right;

		parent->_left = LRnode;
		//LRnode可能为空
		if (LRnode) LRnode->_parent = parent;
		Lnode->_right = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = Lnode;

		if (parent == _root)
		{
			_root = Lnode;
		}
		else if (parent == ppnode->_left)
		{
			ppnode->_left = Lnode;
		}
		else
		{
			ppnode->_right = Lnode;
		}
		Lnode->_parent = ppnode;
		parent->_bf = 0;
		Lnode->_bf = 0;
		return Lnode;
	}

	//左右双旋
	Node* RotateLR(Node* parent)
	{
		Node* Lnode = parent->_left;
		Node* LRnode = Lnode->_right;
		int bf = LRnode->_bf;
		RotateL(Lnode);
		RotateR(parent); 

		LRnode->_bf = 0;
		if (bf == 1)
		{
			parent->_bf = 0;
			Lnode->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			Lnode->_bf = 0;
		}

		//该节点就是新增结点
		else if (bf == 0)
		{
			parent->_bf = 0;
			Lnode->_bf = 0;
		}
		else
		{
			//树出现问题
			assert(false);
		}
		return LRnode;
	}

	//右左双旋
	Node* RotateRL(Node* parent)
	{
		Node* Rnode = parent->_right;
		Node* RLnode = Rnode->_left;
		int bf = RLnode->_bf;
		RotateR(Rnode);
		RotateL(parent);
		RLnode->_bf = 0;
		if (bf == -1)
		{
			Rnode->_bf = 1;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			Rnode->_bf = 0;
			parent->_bf = -1;
		}

		//该节点就是新增结点
		else if (bf == 0)
		{
			Rnode->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			//树出现问题
			assert(false);
		}
		return RLnode;
	}

private:
	Node* _root = nullptr;
};

总结

这里附带一下测试代码

void test_AVLTree1()
{
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16,14 };
	AVLTree<int, int> al;
	for (auto e : a)
	{
		al.Insert(make_pair(e, e));
		cout << e << "->" << al.IsBanlance() << endl;
	}
	al.InOrder();
	cout << al.IsBanlance() << endl;
}

void test_AVLTree2()
{
	const int N = 3500000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; i++)
	{
		v.push_back((rand() + i));
	
	}
	//for (auto e : v)
	//{
	//	cout << e << "   " ;
	//}
	cout << endl;
	size_t begin2 = clock();
	AVLTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}
	size_t end2 = clock();
	cout << t.IsBanlance() << endl;
	cout << "Insert:" << end2 - begin2 << endl;
	cout <<"Height:"<< t.Height() << endl;
	cout << "size:"<<t.size() << endl;
	size_t begin1 = clock();
	int flag = 0;
	for (auto e : v)
	{
		t.Find(e);
		t.Erase(e);
	/*	int i = t.IsBanlance();
		if (i == 0)
		{
			flag++;
		}*/
		
		
	}
	cout << "flag:" << flag << endl;
	for (size_t i = 0; i < N; i++)
	{
		t.Find((rand() + i));
		
	}
	size_t end1 = clock();
	cout << "Find:" << end1 - begin1 << endl;
}

AVL 树是理论上最早提出的自平衡二叉搜索树之一，以其严格的平衡性保障了快速的数据查找操作。在查找密集的应用中，AVL 树因其优越的平衡性被广泛采用。尽管插入和删除操作在 AVL 树中较为复杂，但它依然是一种有效的数据结构选择，特别适合那些更注重查找效率的场景。

ღ 噫吁嚱
关注
c++ AVL树 插入 删除
CoderZhuuu
04-14 1405
AVL树的插入很简单，根据BST树的特性插入之后在回溯的过程中调整即可 AVL树的删除也不是很难，一共有三种情况 第一种是左子树为空（右子树为不为空无所谓） 第二种是右子树为空（此时左子树不为空） 这两种直接用另一半子树覆盖当前节点然后删除再回溯调整树即可 第三种是左右子数都不为空 这个情况首先找到要删除的节点，然后找到比该节点大的节点中最小的一个节点（右子树中最左边的节点），或者比该...
AVL树插入删除算法详解（有图） -- C++语言实现
热门推荐
FreeeLinux's blog
08-14 1万+
一：AVL树介绍 AVL树本质上还是一棵二叉搜索树，它的特点是： 1.本身首先是一棵二叉搜索树。 2.带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。在本文中用分别用-1，0，1定义左边树高，等高，右边树高。平衡因子用m_bf表示。 也就是说，AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）。 二：插入算法 由于AVL树具有BST树的
图解：什么是AVL树？（删除总结篇）
Z景明的博客
05-21 1501
上一篇文章讨论了平衡二叉树的插入操作，没有看的可以去看一下 图解：什么是AVL树？，有助于理解今天要讲的平衡二叉树的删除操作。平衡二叉树的删除操作与插入操作类似，先执行标准的BST删除操...
数据结构：AVLTree的插入和删除的实现
li209779的博客
11-12 1363
本篇博客作为AVL树的插入和删除的实现。如果代码实现有问题，还请大佬们指出。以上就是我对于AVLTree插入和删除的理解。！！
数据结构七之AVL树
qq_44261638的博客
12-14 242
平衡因子：某个节点的左右子树的高差 AVL树的特点： 1、每个节点的平衡因子只可能为0，1，-1 （平衡因子的绝对值<=1） 2、搜索、添加、删除的时间复杂度为O（logn） 普通二叉搜索树和AVL树的搜索比较： 树的继承结构： 实例：往树中添加节点 1、最坏的情况：可能会导致所有的祖先节点全部失衡 2、父节点和非祖先节点都不会 失衡 AVL树添加或删除节点后，通过旋转返回平衡（即把每个节点...
【人工智能】——AI相关知识点梳理
汤庆
03-24 8746
目录 一、人工智能学习思维导图 二、算法小结 三、机器学习知识脉络 四、人工智能论文合集 五、相关主页网址 六、应用领域 一、人工智能学习思维导图 Tips:神经网络和深度学习是什么关系？ 1、从广义上说深度学习的网络结构也是多层神经网络的一种。 传统意义上的多层神经网络是只有输入层、隐藏层、输出层。其中隐藏层的层数根据需要而定，没有明确的理论推导来说明到底多少层...
数据结构与算法-基础（十一）AVL 树
我为双鱼狂
10-24 311
AVL 树 是最早时期发明的自平衡二叉搜索树之一。是依据它的两位发明者的名称命名。 AVL 树有一个重要的属性，即平衡因子（Balance Factor），平衡因子 == 某个节点的左右子树高度差。 AVL 树特点总结下来有： 每个节点的平衡因子有且仅有 1、0、-1，若超过这三个值的范围，就称其为失衡； 每个节点左右子树的高度差不会超过 1； 搜索、添加、删除的时间复杂度为 O(logn)，n 为 n 个节点。 看上图，右侧图中二叉树就可以称为AVL 树。 添加后导致失衡 若再添加一个元素 18，导
C++二叉平衡搜索树：AVL树的插入、删除与平衡
m0_63207201的博客
11-14 1676
AVL树插入、删除、旋转，模拟实现AVL树
【C++】AVL树插入删除
fight_p的博客
12-08 2541
这是一篇深度剖析AVL的插入，删除，以及判断是否是AVL树为主体的内容，其中涉及到LL，RR，LR，RL旋转的详细讲解。并且这是用的三叉实现的AVL树。
C++笔记---AVL树的插入删除
2302_80372340的博客
09-29 1180
AVL树是一颗高度平衡搜索二叉树，通过控制高度差去控制平衡。AVL树得名于它的发明者G. M.
c++《AVL树的概念》《AVL树的插入》《AVL树的旋转》《AVL树的验证》《AVL树的删除》《AVL树的性能》
weixin_45726063的博客
07-20 156
4.1 AVL树 4.1.1 AVL树的概念 二叉搜索树虽可以缩短查找的效率，**但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当 于在顺序表中搜索元素，效率低下。**因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之 差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。 它的左右子树都是AVL树 它左右树高度之差（
AVL树C++实现（插入，删除，查找，清空，遍历操作）
weixin_34405557的博客
12-13 451
AVL.h文件代码 #pragma once #include<iostream> #include<stack> #include <assert.h> using namespace std; using namespace std; template<class T> struct AVLNode{ T data; AVLNo...
C++AVL树的插入平衡和删除平衡：原理+代码（插入篇）
GenjiWang1222的博客
02-12 610
AVL树的插入平衡和删除平衡：原理+代码（插入篇） 目录AVL树的插入平衡和删除平衡：原理+代码（插入篇）前言一、插入平衡的原理二、插入平衡的实现1.引入库2.读入数据总结 前言 由于AVL的插入平衡操作与删除平衡操作网上版本很多，不同的插入与删除不能很好的兼容在一个程序里（思路不同），所以抽空写一个自己完成的插入和删除操作，因为比较懒，所以分开写，这次先写插入平衡操作~ 一、插入平衡的原理 AVL树是一种活跃在大学里的数据结构，简单来说就是二叉搜索树（BST）的2.0强化版，因为二叉搜索树遇到下图的
c++复习笔记18-AVL树（插入+删除）
hou19975418的博客
03-10 330
C++复习笔记
【C++】从「树」到「平衡」：全面解密 AVL 树的奥秘与实现
weixin_74837455的博客
11-24 3377
AVL树是一种自平衡的二叉搜索树，它的名字来源于它的发明者G.M. Adelson-Velsky和E.M. Landis，两位前苏联的科学家在论文《An algorithm for the organization of information》中发表了它。
【C++ 学习 ㉒】- 超详解 AVL 树的插入、平衡调整以及删除（含源代码）
melonyzzZ的博客
09-21 2498
超详解 AVL 树： 一、AVL 树的概念 二、AVL 树节点的定义 三、AVL 树的插入 四、AVL 树的平衡调整 五、AVL 树的删除 六、AVL 树的实现
C++:AVL树的插入，验证及删除操作解析与代码实现(附加4种旋转操作解析与代码实现)
xiuwoaiailixiya的博客
01-20 793
上篇文章我们介绍到了二叉搜索树，同时我们也谈到了它的一种特殊情况。那就是当插入数据是有序的时候，会使树的搜索效率退化到O(N)级别：有没有什么办法能够解决这种问题呢，这时候就要请出我们今天的主角AVL树了。
【C++入门到精通】C++入门 —— AVL 树（自平衡二叉搜索树）
Yawesh的博客
10-04 812
AVL树是一种自平衡二叉搜索树，可以保证树的任何节点的左子树和右子树的高度差不超过1，从而提供了较好的查找、插入和删除操作的时间复杂度保证。AVL树的核心思想是在每个节点上保存一个平衡因子，表示其左子树高度和右子树高度之差。在进行插入和删除操作时，如果插入或删除后导致树的某个节点的平衡因子的绝对值大于1，就需要进行旋转操作来恢复平衡。AVL树的插入和删除操作的时间复杂度都为O(log n)。AVL树的优点是保证树的平衡性，提供了较好的时间复杂度保证；缺点是在进行插入和删除操作时可能需要花费更多的时间和空间。
【C++】AVL树（详解）
最新发布
2401_87820834的博客
08-30 1389
AVL 树的介绍，AVL 树的基本操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值