【高阶数据结构（壹）】——一步一步教你手撕AVL树（增删查改）画图详解，内含代码实现包含注释）

已于 2022-01-19 17:45:47 修改
阅读量878 收藏 21
点赞数 23
分类专栏： 数据结构与算法 文章标签： 数据结构 b树 c++ c语言
于 2022-01-17 21:43:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjp11/article/details/122518207
版权

               🍎作者：努力学习的少年

 

 🍎个人简介：双非大二，一个正在自学c++和linux操作系统，写博客是总结知识，方便复习

 🍎目标：进大厂

 🍎 如果你觉得文章可以的话，麻烦你给我点个赞和关注，感谢你的关注！

目录

📚 1. AVL树的概念

📚 2. AVL树节点的定义

📚  3. AVL树的插入

📚 3. 右单旋

📚 4. 左单旋

📚 5. 左右双旋

📚 6. 右左双旋

📚 7. 插入的总的代码（含注释）

📚 8. AVL树查找的代码

📚  9. 删除

📚 1. AVL树的概念

  1. AVL树一颗二叉搜索树
  2. 左右子树高度之差(简称平衡因子)的绝对值不超过1。

如果一颗AVL树有n个节点，其高度可以保持在O(logn),搜索的时间复杂度是O(logn).

📚 2. AVL树节点的定义

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode* _left;//左孩子节点
	AVLTreeNode* _right;//右孩子节点
	AVLTreeNode* parent;//父亲节点
	int _bf;//平衡因子
	pair<K, V> _kv;//存储数据
	AVLTreeNode(pair<K,V> kv)//节点的构造函数
		:_left(nullptr)
		,_right(nullptr)
		,parent(nullptr)
		,_kv(kv)
		,_bf(0)
	{

	}
};

📚  3. AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步：

  1. 按照二叉搜索树的方式直接插入新节点。
  2. 调整平衡因子（插入在左孩子节点，平衡因子-1，插入到右孩子节点，平衡因子+1）

新节点插入到二叉搜索树中:

插入的过程：根据搜索树的性质找到空位置，将新节点插入到该空位置。

 插入过程：

 插入的代码：

bool insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)//如果是空树，直接插入
		{
			_root = new node(kv);
			return true;
		}

		node* cur = _root;
		node* parent = nullptr;
		while (cur)//寻找相对应的空位置
		{
			if (cur->_kv.first > kv.first)//如果值小于该节点的值，则去它的左子树寻找
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)//如果值大于该节点的值，则去它的右子树寻找
			{
				parent = cur;
				cur = cur->_right;
			}
		}

		node* newnode = new node(kv);//创建新的节点
		newnode->parent = parent;//将新的节点与parent进行连接
		if (parent->_kv.first > kv.first)//判断新节点是连接在parent的左孩子还是右孩子
		{
			parent->_left = newnode;
			parent->_bf--;//插入到parent的左孩子，parent的平衡因子-1
		}
		else if (parent->_kv.first < kv.first)
		{
			parent->_right = newnode;
			parent->_bf++; //插入到parent的右孩子，parent的平衡因子 +1 1
		}
        .......
        .......
}

当然，AVL树中插入新节点后还需要保持是AVL树，所以我们需要向上调整平衡因子。

在插入之前，parent的平衡与因子可能取值是0，1，-1（AVL树的左右子树的高度差不超过1）

插入时，parent的平衡因子的调整分为以下两种情况

  1. 如果cur是插入到parent右节点，则parent的平衡因子加1
  2. 如果是插入到parent的左节点，平衡因子-1；

插入后，parent的平衡因子的可能取值是0，1，-1，2，-2.

  1. 如果parent的平衡因子是0，那么插入前的parent的平衡因子可能取值是1或者-1.插入后被调整为0，此时AVL树高度不变，则插入成功。    如下图：插入13节点后，parent高度不变，不需要往上更新平衡因子。    
  2. 如果parent的平衡因子是-1或者+1,那么插入前的parent的平衡因子一定是0，此时高度增加，需要对parent上面的节点的平衡因子进行调整。如下图插入25这个节点后，则parent的高度增加，则上面的节点的树的高度也增加，需要调整上面的平衡因子。
  3. 如果parent的平衡因子是-2或2，那么parent则违反AVL树的性质，需要对它进行旋转使该树保持平衡。旋转后高度降低，不需要向上调整平衡因子。具体旋转如下解释。

旋转可以分为右单旋，左单旋，右左双旋，左右双旋这4中旋转

📚 3. 右单旋

新节点插入到较高的左子树的左侧，则需要进行有单旋，如下这种情况。

触发右单旋的条件：parent的平衡因子为-2，sub的平衡因子为-1.

上面这个图是抽象图，a，b，c代表着数种情况，但总之，a，b，c的高度都为h。

在上图插入之前，AVL树是平衡的，但我们在节点30的左子树插入一个节点后，导致以根节点的60的二叉平衡树不平衡，即60的平衡因子为-2.并且新插入的节点是在左子树的左子树上，所以我们需要对它进行右单旋。

 在旋转的过程中，我们需要知道：60可能是根节点，也可能是是子树

过程：parent连接subL中的右子树，然后subL的右子树连接parent,parent的parent连接subL,subL

的parent连接pparent，pparent连接subL需要根据以下三种情况讨论。

 

右单旋的代码实现：

		void RightRevole(Node*& parent)
		{
			Node* pparent = parent->_parent;
			Node* subL = parent->_left;
			Node* subLR = subL->_right;
			parent->_left = subLR;//subL的右孩子连接到parent的左孩子节点上
			if (subLR)
			{
				subLR->_parent = parent;

			}
			
			if (pparent)//pparent不为空
			{
				if (pparent->_left == parent)//parent位于pparent左节点上
				{
					pparent->_left = subL;//subL连接到pparent的左孩孩子节点上
				}
				else if (pparent->_right == parent)//parent位于pparent右节点上
				{
					pparent->_right = subL;//subL连接到pparent的右孩孩子节点上
				}
				subL->_parent = pparent;//pparent连接到subL的parent的节点上
			}
			else//pparent为nullptr
			{
				_root = subL;//subL直接变为根节点
				subL->_parent = nullptr;//subL的parent指向空
			}
			subL->_right = parent;//subL的右节点连接parent
			parent->_parent = subL;//parent的parent连接subL
		}

📚 4. 左单旋

 实际情况跟右单旋基本差不多的，只要看懂右单旋，左单旋也就会了。

左单旋的触发条件是：parent的平衡因子为2，subR的平衡因子为1。

左单旋的过程：

		void LeftRevole(Node*& parent)
		{
			Node* pparent = parent->_parent;
			Node* subR = parent->_right;
			Node* subRL = subR->_left;
			parent->_right = subRL;
			if (subRL)
			{
				subRL->_parent = parent;
			}
			if (pparent)//pparent不为空
			{
				if (pparent->_left == parent)//parent为pparent的左孩子的节点上
					pparent->_left = subR;//subR连接到pparent的左孩子节点上
				else if (pparent->_right == parent)//parent为pparent的右孩子的节点上
					pparent->_right = subR;//subR连接到pparent的右孩子节点上
				subR->_parent = pparent;//subR的parent连接pparent
			}
			else//pparent为空
			{
				_root = subR;//subR直接为根节点
				_root->_parent = nullptr;//_root的parent的指向空
			}
			subR->_left = parent;//subR的left连接parent
			parent->_parent = subR;//parent的parent连接subR
		}

📚 5. 左右双旋

新节点插入到较高左子树的右侧上，此时的就需要进行左右双旋。

左右双旋的条件：parent的平衡因子为-2，subL的平衡因子为1.

过程：先对subL进行左单旋，然后在对parent进行右单旋，最后在调节平衡因子（下列中有分析）。

例如下面这种情况：

左右单旋的平衡因子有三种情况：

  1. 如果新节点插入到subLR的左子树（b子树）上，旋转前subLR的平衡因子为-1.那么结果如上图所示,旋转后subLR的平衡因子为0，subL的平衡因子为0，parent的平衡因子为1.
  2. 如果新节点插入到subLR的右子树（c子树）上，旋转前subLR的平衡因子为1，如下图所示，旋转后subLR的平衡因子为0，subL的平衡因子为-1，parent的平衡因子为0.

 3. 另外一种情况是subLR的平衡因子为0，通过左右旋转后subLR,subL,parent的平衡因子都为0.

	void LRrevole(node* parent)
	{
		node* subL = parent->_left;
		node* subLR = parent->_left->_right;
		LeftRevole(subL);//对subL进行左单旋
		RightRevole(parent);//对parent进行右单旋
		if (subLR->_bf == -1)//subLR的平衡因子为-1
		{
			parent->_bf = 1;
			subLR->_bf = 0;
			subL->_bf = 0;
		}
		else if (subLR->_bf == 1)//subLR的平衡因子为1
		{
			subL->_bf = -1;
			subLR->_bf = 0;
			parent->_bf = 0;
		}
		else if (subLR->_bf == 0)//subLR的平衡因子
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 0;
		}
	}

📚 6. 右左双旋

新节点插入到较高右子树的左侧，此时就需要进行右左双旋。

右左双旋的条件为：parent的平衡因子为2，subR的平衡因子为-1。

右左双旋后的平衡因子有三种情况：

  1. 如果subRL的平衡因子为1，则旋转后parent的平衡因子为-1，subR的平衡因子为0,subRL的平衡因子为0.
  2. 如果subRL的平衡因子为-1，则旋转后parent的平衡因子为0，subR的平衡因子为1,subRL的平衡因子为0.
  3. 如果subRL的平衡因子为0，则旋转后parent，subR和subRL的平衡因子都为0.

代码实现：

	void RLrevole(node* parent)
	{
		node* subR = parent->_right;
		node* subRL = subR->_left;
		RightRevole(subR);//对subR的进行右单旋
		LeftRevole(parent);//对parent进行左单旋
		if (subRL->_bf == -1)//subRL的平衡因子为-1
		{
			subR->_bf = 1;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else if (subRL->_bf== 1)//subRL的平衡因子为1
		{
			parent->_bf = -1;
			subRL->_bf = 0;
			subR->_bf = 0;
		}
		else if (subRL->_bf == 0)//subRL的平衡因子为0
		{
			subRL->_bf = 0;
			subR->_bf = 0;
			parent->_bf = 0;
		}
	}

📚 7. 插入的总的代码（含注释）


	bool insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)//如果是空树，直接插入
		{
			_root = new node(kv);
			return true;
		}

		node* cur = _root;
		node* parent = nullptr;
		while (cur)//cur不为空
		{
			if (cur->_kv.first > kv.first)//如果值小于该节点的值，则去它的左子树寻找
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)//如果值大于该节点的值，则去它的右子树寻找
			{
				parent = cur;
				cur = cur->_right;
			}
		}

		node* newnode = new node(kv);//创建新的节点
		newnode->parent = parent;//将新的节点与parent进行连接
		if (parent->_kv.first > kv.first)//判断新节点是连接在parent的左孩子还是右孩子
		{
			parent->_left = newnode;
			parent->_bf--;
		}
		else if (parent->_kv.first < kv.first)
		{
			parent->_right = newnode;
			parent->_bf++;
		}
		//向上更新平衡因子
		while (parent)
		{
			node* pparent = parent->parent;
			if (parent->_bf == 0)//平衡因子等于0直接跳出循环
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)//平衡因子为1或者-1，需要更新上面的平衡因子
			{
				
				if (pparent==nullptr)
				{
					break;
				}
				else if (pparent->_left == parent)//parent是位于pparent的左节点
				{
					pparent->_bf--;//pparent的平衡因子-1
				}
				else if (pparent->_right == parent)//parent是位于pparent的右节点
				{
					pparent->_bf++;//pparent的平衡因子+1
				}
				parent = pparent;//parent向上爬
			}
			else if (parent->_bf == 2 || parent->_bf == -2)//进行旋转
			{
				if (parent->_bf == 2)//parent的平衡因子为2
				{
					if (parent->_right->_bf == 1)//parent的右孩子的平衡因子为1
					{
						//左单旋
						LeftRevole(parent);			
					}
					else if (parent->_right->_bf == -1)//parent的右孩子的平衡因子为-1
					{
						//先右旋在左单旋
						RLrevole(parent);
					}
				}
				else if (parent->_bf == -2)//parent的平衡因子为-2
				{
					if (parent->_left->_bf == -1)//parent的左孩子的平衡因子为-1
					{
						//右单旋
						RightRevole(parent);
					}
						else if (parent->_left->_bf == 1)//parent的右孩子的平衡因子为1
					{
						//先左单旋在右单旋
						LRrevole(parent);
					}
				}
				break;//旋转之后都是平衡树，直接跳出循环
			}
		}
	}

📚 8. AVL树查找的代码

	node* find(const K& key)
	{
		node* cur = _root;
		while (cur)
		{
			if (cur->_kf->first > key)//key值小于cur，到左子树找
			{
				cur = cur->_left;
			}
			else if (cur->_kf->first < key)//key值大于cur，到右子树找
			{
				cur = cur->_right;
			}
			else if (cur->_kf->first == key)//找到了，返回该节点
			{
				return cur;
			}
		}
		return nullptr;//找不到，返回空
	}

📚  9. 删除

AVL树的删除也是分为两步：

  1. 找到要删除节点，将该节点删除。
  2. 调整平衡因子

删除AVL树有四种情况：

情况一

删除的节点不存在左右子树。

那么我们直接将该节点删除即可，例如我们要删除cur，我直接将cur删除掉即可，然后在调整parent的平衡因子。

情况二

要删除的节点只存在左子树，不存在右子树。

例如删除15这个节点，我们需要将subL和parent互相连接，然后parent的平衡因子+1或者-1.

过程如下：

情况三

要删除的节点只存在右子树，不存在左子树。

例如删除4这个节点，我们需要将subR和parent互相连接，然后parent的平衡因子+1或者-1.

过程如下：

情况四

要删除的节点存在左右子树。

例如我们要删除11这个节点，我们可以找到cur右子树上的最小值Rightmin（也就是右子树上最左边上的值）然后将该Rightmin节点的值赋值给cur这个节点,将Rightmin这个节点删除掉，在删除Rightmin节点之前，需要先让parent指向Rightmin的parent，调整parent的平衡因子，因为我们删除的是Rightmin，是会影响Rightmin以上的平衡因子。

 

 

 对parent及以上进行调整平衡因子：

在这里我们只讨论左单旋跟右单旋其中两种特殊情况旋转后的平衡因子，其它的旋转调整跟插入是一样的。

在之前的插入，当parent的平衡因子为-2，subL的平衡因子为-1,才对parent节点进行左旋，左旋后的parent和subL的平衡因子都为0，当删除60的时候，parent节点的平衡因子为-2，就需要进行左旋，由于subL节点的平衡因子为0，所以它的左旋后的parent平衡因子变为-1，subL的平衡因子为1。如下图：

删除前：

删除60节点后： 

 左旋转后：

 同样的，当删除后parent平衡因子为2，subR的平衡因子为0，需要进行右旋。

删除13这个节点前：

 删除13节点后：

进行右旋后：右旋后的parent的平衡因子为1，subR的平衡因子为-1.

 每次旋转后都不需要往上更新平衡因子，因为旋转后高度都会降低，不会影响上面节点的平衡因子。

	bool erase(const K& key)
	{
		node* cur = find(key);//查找cur
		if (cur == nullptr)//找不到
		{
			return false;
		}

		//找到了
		node* parent = cur->parent;
		if (cur->_left == nullptr && cur->_right == nullptr)//如果要删除的节点的左右孩子为空
		{
			if (parent->_left == cur)//cur为parent的左边，平衡因子+1
			{
				parent->_bf++;
			}
			else//cur为parent的右边，平衡因子-1
			{
				parent->_bf--;
			}
			delete cur;//直接删除
			cur = nullptr;
			//平衡因子
		}
		else if (cur->_left && cur->_right)//要删除的节点中的左右孩子都存在
		{
			node* rightmin = cur->_right;//右子树的最小节点
			while (rightmin->_left)//查找右子树的最小值
			{
				rightmin == rightmin->_left;
			}
			cur->_kv = rightmin->_kv;//将右子树的最小值给要删除的节点，然后删除rightmin
			parent = rightmin->parent;//rightmin的父亲
			if (rightmin->_right)//rightmin存在右子树
			{
				node* right = rightmin->_right;
				parent->_right = right;//将rightmin的右子树给parent
				right->parent = parent;//右子树的父亲连接parent
			}
			else
			{
				parent->_right = nullptr;//右子树不存在，连接nullptr
			}
			delete rightmin;//直接删除rightmin
			rightmin = nullptr;
			parent->_bf--;//right的父亲的平衡因子-1
		}
		else if (cur->_left)//cur的左子树不为空，右子树不存在
		{
			if (cur == _root)//cur为根节点
			{
				_root = cur->_left;
				_root->parent = nullptr;
			}
			else//cur不是根节点
			{
				node* subL = cur->_left;//cur的左子树
				if (parent->_left == cur)//cur是parent的左子树
				{
					parent->_left = subL;//parent的左子树连接subL
					parent->_bf++;//parent的平衡因子+1
				}
				else
				{
					parent->_right = subL;//parent的右子树连接subL
					parent->_bf--;//parent的平衡因子-1
				}
				subL->parent = parent;//subL的parent连接cur的parent
			}
			delete cur;
			cur == nullptr;
		}

		else if (cur->_right)//cur的右子树不为空，左子树不存在
		{
			if (cur == _root)
			{
				_root = cur->_right;
				_root->parent = nullptr;
			}
			else
			{
				node* subR = cur->_right;//cur的右子树
				if (parent->_left == cur)//cur是parent的左子树
				{
					parent->_left = subR;//parent的左子树连接subR
					parent->_bf++;
				}
				else
				{
					parent->_right = subR;//parent的右子树连接subR
					parent->_bf--;
				}
				subR->parent = parent;
			}
			delete cur;
			cur == nullptr;
		}

		//更新平衡因子
		while (parent)//parent为nullptr，则停下来
		{
			node* pparent = parent->parent;
			if (parent->_bf == 0)//平衡因子等于0
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{

				if (pparent == nullptr)//parent是根节点
				{
					break;
				}
				else if (pparent->_left == parent)//parent是pparent的左节点
				{
					pparent->_bf--;
				}
				else if (pparent->_right == parent)//parent是pparent的右节点
				{
					pparent->_bf++;
				}
				parent = pparent;//parent向上移动
			}
			else if (parent->_bf == 2 || parent->_bf == -2)//parent
			{
				if (parent->_bf == 2)
				{
					if (parent->_right->_bf == -1)//parent的右孩子节点的平衡因子为-1
					{
						//先右旋在左单旋
						RLrevole(parent);
					}
					else //parent的右孩子节点的平衡因子为1或者0
					{
						//左单旋
						node* subR = parent->_right;
						LeftRevole(parent);
						if (subR->_bf == 0)//parent的右孩子节点的平衡因子为0
						{
							//改变平衡因子
							subR->_bf = -1;
							parent->_bf = 1;
						}

					}
				}
				else if (parent->_bf == -2)
				{
					if (parent->_left->_bf == 1)
					{
						//先左单旋在右单旋
						LRrevole(parent);
						
					}
					else //parent的右孩子节点的平衡因子为-1或者0
					{
						//右单旋
						node* subL = parent->_left;
						RightRevole(parent);
						if (subL->_bf == 0)//parent的右孩子节点的平衡因子为0
						{
							parent->_bf = -1;
							subL->_bf = 1;
						}
					}
				}
				break;//旋转之后都是平衡树，直接跳出循环
			}
		}
	}

 下篇高阶数据结构预告：手撕红黑树

感谢你的关注和收藏！！！

种一颗树最后是十年前，其次是现在！！！！！


               

         

努力学习的少年
关注
  • 23
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
专栏目录
AVL树的c语言实现代码（添加和删除）
01-06
这个代码是关于AVL树的添加和删除的实现
C++版AVL树课程设计源代码
11-04
该程序通过C++实现了AVL树的一些基础操作：1.编写AVL树判别程序，并判别一个二叉搜索树是否为AVL树；2.实现AVL树的ADT，包括其上的基本操作：结点的加入和删除；3.实现基本操作的动态演示(图形演示)；最重要的是，该程序可以画出你所输入的树
AVL树的删除操作
06-08
AVL树的删除程序，包括完整的源代码和可执行程序
AVL树的细节实现_课程设计文档+代码
12-27
该文档为毕业论文，完全按照毕业论文格式书写。 包含课程设计文档和代码。 用于结课考试和毕业答辩。 也可作为同学学习使用。
数据结构之AVL树详解
12-26
1. 概述 AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下都是O（log n），增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。本文介绍了AVL树的设计思想和基本操作。 2. 基本术语 有四种种情况可能导致二叉查找树不平衡，分别为： （1）LL：插入一个新节点到根节点的左子树（Left）的左子树（Left），导致根节点的平衡因子由1变为2 （2）RR：插入一个新节点到根节点的右子树（Right
AVL树的 插入 和 删除
潜心钻研技术
03-11 1738
AVL树的 插入 和 删除
avl树remove方法java,AVL树 05 删除节点
weixin_34741145的博客
03-18 157
从AVL树中删除节点在子树中删除元素后，返回的根节点链在node节点后，可能对node的平衡性造成破坏，需要对node的平衡性做检查，当平衡性被打破的时候，需要重新调整node的平衡性，调整完成后才能将结果返回到递归的上一层；在removeMin中可能会打破该树的平衡性，改成递归调用remove(node.right, successor.key)；因为remove方法中已经有了维护平衡性的操作；...
AVL树详解与实现
naturerun的博客
12-02 987
AVL树详细分析以及插入删除的c++实现
看数据结构写代码（57） AVL树的删除
fuming0210sc的专栏
04-22 834
上一节 已经说了 AVL树的插入 操作，可是 只有 插入，没有删除，怎么能叫 动态 查找表呢。 呵呵，博主 赶紧 去 研究了一番。下面 是成果： AVL树的删除 大致 分为 两大块： 1. 查找节点 并 删除 2. 保持 删除 后 平衡因子的 影响 1. 首先 找到 这个 节点，如果 节点 不存在，直接 退出 函数 if (*tree == NULL){//没找到
平衡二叉树的删除
weixin_57023347的博客
09-05 1188
目录 前言 一.结点定义 二.删除 2.1 按照二叉搜索树来删除结点 2.2 更新平衡因子 2.3 检测更新完的平衡因子 三.完整代码 前言 之前再C语言阶段学习了平衡二叉树，用C语言递归实现了一下平衡二叉树的删除与插入。实现如下：数据结构——平衡二叉树(AVL树)之插入和数据结构——平衡二叉树之删除当时学习的时候感觉比较费劲，并且难以理解。 现在在C++阶段又重新学习了一下平衡二叉树，使用非递归实现，再加上结点引入平衡因子和父节点，感觉更好理解了。 ...
基于Python实现的数据结构与算法完整源代码+超详细注释(包含46个作业项目).zip
01-02
基于Python实现的数据结构与算法完整源代码+超详细注释(包含46个作业项目) 项目包含： 01_变位词问题 02_python数据类型的性能 03_python实现ADT Stack 04_栈的应用1括号匹配 05_栈的应用2十进制转二进制 06_栈的...
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
主要介绍了C语言数据结构之平衡二叉树（AVL树）实现方法,结合实例形式分析了C语言平衡二叉树的相关定义与使用技巧,需要的朋友可以参考下
AVL.rar_avl_数据结构代码
09-22
ALV树完整分析以及C++具体代码的实现，数据结构的难点。
手撕AVL树 (C++ 实现）
林慢慢的博客
06-29 936
AVL 树的定义、代码实现、性能分析
【C++/STL】手撕AVL树
qq_53893431的博客
08-02 368
AVL树和map中的问题
算法--AVL树的删除
tang_jin2015的专栏
02-27 1958
AVL 树删除 定义 AVL树是一棵二叉查找树，平衡因子为-1，1，0.若平衡因子为2就必须进行平衡化。平衡化的过程就是左旋或者右旋，分LL,LR,RR,RL4种情况。 性能： 高度为:log(n),在最坏的情况下要比较O(logn)次。与其它的平衡树不同，当一个结点出现不平衡，可能会影响整棵树。 过程，比如一个数组为5,6,8,3,2,4,7。长度为7。那么插入的情况是 定义
AVL树删除节点deletenode函数分析 （C++实现）
Tokameine的博客
02-05 1492
先放一下代码：（这里只放一些必要的内容。因为每个人的习惯不同，只有思路可以借鉴。请注意注释。关于旋转函数，我在上一篇帖子分析insert时贴出过，仅供参考。如果在某个地方没有理解，请先继续往下看一会，或许能找到答案。如果发现代码和解释有问题，请务必指出。） typedef struct avlnode* position; typedef struct avlnode* avltree; struct avlnode{ avltree left; avltree right; int heigh.
天天说手撕AVL树？你真的能撕下来吗？（详细解释+代码注释）
CYK_byte的博客
12-20 723
为什么要引入AVL树？我们熟知的二叉搜索树虽然在原来二叉树的基础上已经缩短了查找的效率，但是若数据有序，或接近有序的二叉搜索树将会退化成一个单支树，查找的效率相当于在顺序表中搜索元素，有悖引入二叉搜索树的初衷了；这时候就出现了AVL树，可以很好的接近上述问题；怎么解决？请往下看~接下来本文将用最简洁明了的话语、最详细的代码、最详细的注释，带你深入以及模拟实现一个AVL树；
数据结构（python）之小杨笔记一
最新发布
m0_74811962的博客
05-10 353
数据结构：数据结构是计算机科学中研究数据组织、管理和存储方式的一门重要领域。（5.）树：一种非线性的数据结构，由节点和边组成，每个节点最多有一个夫节点和多个子节点。（2.）链表：由一系列节点组成的数据结构，每个结构包含数据和指向下一个节点的指针。（3.）图的算法：用于解决图结构中的各种问题的算法，如最短路径，最小生成树。的数据结构，只能在队列的前端进行删除操作，在队列的后端进行插入操作。（6.）图：一种包含节点和边的数据结构，用于表示对象之间的关系。（1.）堆：一种特殊的树形数据结构，用于实现。
山东大学数据结构课程设计avl树的实现
07-23
总之，山东大学数据结构课程设计要求实现AVL树，通过定义节点结构和实现插入、删除和查找操作，可以实现一个具有良好平衡性和高效性能的AVL树。 ### 回答2： 山东大学的数据结构课程设计中，我实现了AVL树。 AVL...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值