AVL树插入代码(单旋、双旋)

最新推荐文章于 2022-08-23 00:34:44 发布
最新推荐文章于 2022-08-23 00:34:44 发布
阅读量150 收藏
点赞数
分类专栏： C++基础 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Heck_Jacke/article/details/126403442
版权

AVL树的插入案例：

几点说明

  • 每个node有一个平衡因子，左子树插入节点，平衡因子-1，右子树插入节点，平衡因子+1
  • 右单旋条件：该节点(parent)平衡因子-2，左儿子(subL)平衡因子为-1，则Rrevole(parent)，旋转后两个平衡因子置为0；
  • 左单旋条件：该节点(parent)平衡因子2，右儿子(subR)平衡因子为1，则Lrevole(parent)，旋转后两个平衡因子置为0；
  • 右左双旋条件：该节点(parent)平衡因子2，右儿子(subR)平衡因子为-1，则先右单选右儿子Rrevole(subR)，再左单旋Lrevole(parent)，这两个单选的过程中平衡因子暂不处理，统一交由RLrevole处理；
  • 左右双旋条件：该节点(parent)平衡因子-2，左儿子(subL)平衡因子为1，则先单旋左儿子Lrevole(subL)，再右单旋Rrevole(parent)，平衡因子处理同上。

左单旋和右单旋要处理平衡因子的情况：

void Rrevole(node* parent) {
		node* subL = parent->_left;
		node* pparent = parent->parent;
		node* subLR = subL->_right;
		if (parent->_bf * subL->_bf == 2) {
			parent->_bf = 0;
			subL->_bf = 0;
		}
		subL->parent = pparent;
		parent->parent = subL;
		parent->_left = subLR;
		subL->_right = parent;
		if (subLR) {
			subLR->parent = parent;
		}
		if (pparent == nullptr) {
			_root = subL;
			return;
		}
		if (pparent->_left == parent) {
			pparent->_left = subL;
		}
		else if (pparent->_right == parent) {
			pparent->_right = subL;
		}
	}

	void Lrevole(node* parent) {
		node* subR = parent->_right;
		node* pparent = parent->parent;
		node* subRL = subR->_left;
		if (parent->_bf * subR->_bf == 2) {
			parent->_bf = 0;
			subR->_bf = 0;
		}
		subR->parent = pparent;
		parent->parent = subR;
		parent->_right = subRL;
		subR->_left = parent;
		if (subRL) {
			subRL->parent = parent;
		}
		if (pparent == nullptr) {
			_root = subR;
			return;
		}
		if (pparent->_left == parent) {
			pparent->_left = subR;
		}
		else if (pparent->_right == parent) {
			pparent->_right = subR;
		}

	}

左右双旋以及右左双旋的平衡因子分别有三种情况：

void RLrevole(node* parent) {
		node* subR = parent->_right;
		node* subRL = subR->_left;
		Rrevole(subR);
		Lrevole(parent);
		if (subRL->_bf == 1) {
			parent->_bf = -1;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else if (subRL->_bf == -1) {
			parent->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (subRL->_bf == 0) {
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
	}

	void LRrevole(node* parent) {
		node* subL = parent->_left;
		node* subLR = subL->_right;
		Lrevole(subL);
		Rrevole(parent);
		if (subLR->_bf == 1) {
			parent->_bf = 0;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		else if (subLR->_bf == -1) {
			parent->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (subLR->_bf == 0) {
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
	}

总插入代码与实际案例：

#include <iostream>
#include <utility>
using namespace std;

template <class K, class V>
struct AVLTreeNode {
	AVLTreeNode* parent;
	AVLTreeNode* _left;
	AVLTreeNode* _right;
	pair<K, V> _kv;
	int _bf;
	AVLTreeNode(pair<K, V> kv)
		: parent(nullptr)
		, _left(nullptr)
		, _right(nullptr)
		, _kv(kv)
		, _bf(0) 
	{
	
	}
};

template<class K, class V>
class AVLTree {
public:
	typedef struct AVLTreeNode<K, V> node;
	AVLTree(int size = 0, node* root = nullptr)
		:_size(size)
		,_root(root)
	{
	
	}
	void Rrevole(node* parent) {
		node* subL = parent->_left;
		node* pparent = parent->parent;
		node* subLR = subL->_right;
		if (parent->_bf * subL->_bf == 2) {
			parent->_bf = 0;
			subL->_bf = 0;
		}
		subL->parent = pparent;
		parent->parent = subL;
		parent->_left = subLR;
		subL->_right = parent;
		if (subLR) {
			subLR->parent = parent;
		}
		if (pparent == nullptr) {
			_root = subL;
			return;
		}
		if (pparent->_left == parent) {
			pparent->_left = subL;
		}
		else if (pparent->_right == parent) {
			pparent->_right = subL;
		}
	}

	void Lrevole(node* parent) {
		node* subR = parent->_right;
		node* pparent = parent->parent;
		node* subRL = subR->_left;
		if (parent->_bf * subR->_bf == 2) {
			parent->_bf = 0;
			subR->_bf = 0;
		}
		subR->parent = pparent;
		parent->parent = subR;
		parent->_right = subRL;
		subR->_left = parent;
		if (subRL) {
			subRL->parent = parent;
		}
		if (pparent == nullptr) {
			_root = subR;
			return;
		}
		if (pparent->_left == parent) {
			pparent->_left = subR;
		}
		else if (pparent->_right == parent) {
			pparent->_right = subR;
		}

	}

	void RLrevole(node* parent) {
		node* subR = parent->_right;
		node* subRL = subR->_left;
		Rrevole(subR);
		Lrevole(parent);
		if (subRL->_bf == 1) {
			parent->_bf = -1;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else if (subRL->_bf == -1) {
			parent->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (subRL->_bf == 0) {
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
	}

	void LRrevole(node* parent) {
		node* subL = parent->_left;
		node* subLR = subL->_right;
		Lrevole(subL);
		Rrevole(parent);
		if (subLR->_bf == 1) {
			parent->_bf = 0;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		else if (subLR->_bf == -1) {
			parent->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (subLR->_bf == 0) {
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
	}

	bool insert(const pair<K, V>& kv) {
		if (!_root) {
			_root = new node(kv);
			return true;
		}
		node* cur = _root;
		node* parent = nullptr;
		while (cur) {
			if (cur->_kv.first < kv.first) {
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first) {
				parent = cur;
				cur = cur->_left;
			}
		}
		node* newnode = new node(kv);
		newnode->parent = parent;
		if (parent->_kv.first < kv.first) {
			parent->_right = newnode;
			parent->_bf++;
		}
		else if (parent->_kv.first > kv.first) {
			parent->_left = newnode;
			parent->_bf--;
		}

		while (parent) {
			node* pparent = parent->parent;
			if (parent->_bf == 0) {
				break;
			}
			else if (parent->_bf == -1 || parent->_bf == 1) {
				if (pparent == nullptr) {
					break;
				}
				else if (parent == pparent->_left) {
					pparent->_bf--;
				}
				else if (parent == pparent->_right) {
					pparent->_bf++;
				}
				parent = pparent;
			}	
			else if (parent->_bf == -2 || parent->_bf == 2) {
				if (parent->_bf == -2) {
					if (parent->_left->_bf == -1) {
						Rrevole(parent);
					}
					else if (parent->_left->_bf == 1) {
						LRrevole(parent);
					}
				}
				else if (parent->_bf == 2) {
					if (parent->_right->_bf == 1) {
						Lrevole(parent);
					}
					else if (parent->_right->_bf == -1) { 
						RLrevole(parent);
					}
				}
				break;
			}
		}
	}


private:
	int _size;
	node* _root;
};
typedef pair<int, int>PII;

int main() {
	AVLTree<int, int> AVL(100);
	AVL.insert(PII(914, 1));
	AVL.insert(PII(1167, 2));
	AVL.insert(PII(8279, 3));
	AVL.insert(PII(9923, 4));
	AVL.insert(PII(328, 5));
	AVL.insert(PII(3439, 6));
	AVL.insert(PII(3640, 7));
	AVL.insert(PII(6103, 8));
	AVL.insert(PII(6104, 9));

	return 0;
}

在这里插入图片描述

肖源杰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL 树的插入以及简单代码实现
m1059247324的博客
06-28 749
AVL 树 概念 AVL树是最先发明的自二叉搜索树。因为一旦二叉搜索树插入的数据接近有序，那么则会退化成为一颗单支叶树，相当于一个链表，查找效率低下。但在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。严格保证了树的高度，大大提高了查找的效率，但是增加和删除可能需要通过一次或多次旋转来重新平衡这个树。 特点 本身首先是一棵二叉搜索树。 它的左右子树都是 AVL 树 带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。 如果一棵二叉搜索树是高度平衡的，它就是AV
【C++】AVL树的插入实现
QiHai的博客
11-09 755
介绍提高查找二叉树的效率的方法-平衡搜索二叉树中的实现方法之一AVL树
AVL树【图示详解+代码实现】
smf12138的博客
08-23 2285
对AVL树这个较复杂的数据结构进行讲解，重点讲解了对AVL树的四种旋转操作，对于这四种旋转都做了非常详细的画图分析，并且对代码进行了实现，还有对于AVL树的验证代码及AVL树的性能分析也做了介绍.
平衡二叉树(AVL树)C++代码实现
RealCoder的博客
07-25 3631
目录平衡二叉树定义AVLAVLAVL树类的封装AVLAVLAVL树的插入操作与平衡化LLLLLL型调整RRRRRR型调整LRLRLR型调整RLRLRL型调整AVLAVLAVL树查找操作AVLAVLAVL树删除结点操作总源代码 平衡二叉树定义 为了使二叉排序树的平均查找长度更小，需要适当控制树高，显然，控制树高的一个有效措施就是尽量保持树的左右子树高度大致平衡，由此产生了平衡二叉树的概念。 G.M.Adelson−VelskiiG.M.Adelson-VelskiiG.M.Adelson−Velskii和E.
Java实现AVL树（自平衡二叉搜索树）
m0_60936579的博客
10-12 962
一、AVL树的概念 AVL树本质上是一棵二叉搜索树，即它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树。另外，AVL树每个结点的左右子树的高度之差，即平衡因子的绝对值不超过1，以实现查询操作的时间复杂度从传统二叉搜索树的O(N)降为O(logN)。 二、平衡调整 首先，为什么AVL树需要有“自平衡”的功能？其实从A...
潜析AVL树–AVL树的双旋转
01-06
潜析AVL树–AVL树的双旋转 接上篇博文：简析AVL树–AVL树的概念及单旋转 AVL树如何恢复平衡之双旋转 首先假设我们有一颗已经处于平衡的AVL树： 上篇博文已经解决了LL和RR两种情况的平衡恢复解决方案—-单旋转。这篇...
avl.rar_AVL树_avl 旋转_树 旋转
09-24
实现了AVL树的查找，删除，四种旋转。可以直接运行
AVL.rar_AVL树_avl_avl树源代码
09-14
AVL tree。 AVL树的源代码。以及基本函数
AVL树的模拟实现代码
最新发布
06-19
AVL树代码
Avl树插入、删除c++实现
03-11
最近在看数据结构，用c++实现了下avl树插入、删除、打印实现。实现之后，只达到可以使用的程度，还有较大的重构、优化空间。有感兴趣的同学 可以尝试改进，拿来共享。共同进步
AVL树的代码（插入和删除算法）
flyinglittleegg的博客
03-02 264
#include<iostream> #include<vector> #include<stack> using namespace std; template<class type> class AVL; template<class type> class AVLnode { public: friend class AVL<int>; public: AVLnode(AVLnode<type>* L ...
AVL树插入、删除的分析与实现
有点甜
07-10 4321
AVL树基本概念 首先，AVL树也是一种
AVL旋转图及其代码的实现
每天学习一点点，成长一小步
06-04 971
1） 左单旋转 未插入前： 插入后： 旋转图： 旋转后： 下面是左单旋代码的实现： void _Rotatel(Node* parent) //左单旋 { Node* pSubR=parent->_pright; Node* pSubRL=pSubR->_pleft; Node * pPParent=paren
AVL树（平衡二叉树）的建立、插入及调整（完整代码）
晴空
02-03 1632
把算法笔记的代码补齐了 《算法笔记》P327 主要是LL、LR、RR、RL几种旋转调整、height的获得、平衡因子的获得 代码： #include <stdio.h> #include <algorithm> using namespace std; struct node{ int v,height; node *lchild; node *rchild; };...
AVL树详解（附c++代码）
u012148952的博客
08-14 5246
详解AVL树的左旋和右旋，以及插入和删除两种基本操作。并且实现一颗简单的AVL树
手撕，高级数据结构——AVL树的实现和插入方法
回水的博客
07-31 1163
AVL树的实现和插入方法
平衡二叉搜索树（AVL树）的原理及实现源代码（有图文详解和C++、Java实现代码）
遨游网络huster的专栏
11-22 6022
这几天学习了AVL树（平衡二叉搜索树），遂写一篇总结与大家分享。包括五个部分： 一、AVL树（平衡二叉搜索树）是什么？ 二、为什么要用AVL树？ 三、AVL树的实现原理 四、完整的实现代码（C++和Java） 五、测试程序分析
C++：AVL树的插入详解
AngelDg的博客
04-29 621
AVLAVL树的概念 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法:当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整...
AVL树的插入操作（四种情况）
PYH的博客
08-25 4244
主要内容为AVL树的插入操作（不包含重复值），主要分为四种情况
用C++代码写AVL树的旋转代码
03-13
以下是一个简单的C代码实现AVL树的旋转： //左旋转 AVLNode* leftRotate(AVLNode* node){ AVLNode* right = node->right; AVLNode* rightLeft = right->left; right->left = node; node->right = rightLeft; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值