avl树的简单实现

最新推荐文章于 2024-11-09 13:08:09 发布

我是聪明的懒大王懒洋洋

最新推荐文章于 2024-11-09 13:08:09 发布

阅读量39

点赞数 1

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/heixiu_heixiuhei/article/details/132276545

版权

#pragma once
#include <iostream>
#include <assert.h>

using namespace std;
template <class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;

	pair <K, V> _kv;
	int _bf; //balance factor 平衡因子

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


template <class K, class V>
struct AVLTree
{
	typedef AVLTreeNode<K, V> node;
public:
	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;
			}
			else
			{
				return false;
			}
		}

		//找到对应节点后进行链接
		cur = new node(kv);
		if (kv.first < parent->_kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;

		//插入结束后，需要控制平衡,平衡是通过平衡因子来看的，所以插入完第一步先更新平衡因子
		while (parent)//由于最坏情况可能会一直向上更新到跟节点，所以这里用parent不为空
		{
			//先更新parent
			if (cur == parent->_left)
			{
				parent->_bf++;
			}
			else if (cur == parent->_right)
			{
				parent->_bf--;
			}
			//向上更新
			if (parent->_bf == 0)
			{
				break;
			}
			else if (abs(parent->_bf) == 1)
			{
				parent = parent->_parent;
				cur = cur->_parent;
			}
			else if (abs(parent->_bf) == 2)
			{
				//说明parent所在子树已经不平衡，需要旋转处理
				if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else
				{
					assert(false);
				}
				break;
			}
			else
			{
				assert(false);//这里由于程序正常的话是不会走到这一行的，所以如果报错一定是平衡因子模块出现了问题
			}
		}
		return true;
	}

	



private:
	node* _root = nullptr;

	void RotateL(node* parent)
	{
		//这里需要分类讨论一共有两种情况
		//1.parent是根节点，需要更改根节点
		//2.parent是子树，需要更改原parent的上一层指向
		node* subr = parent->_right;
		node* subrl = subr->_left;
		node* ppnode = parent->_parent;
		subr->_left = parent;
		parent->_right = subrl;
		parent->_parent = subr;
		if (subrl)//subrl有可能为空
		{
			subrl->_parent = parent;
		}
		//1.根节点情况
		if (_root == parent)
		{
			_root = subr;
			subr->_parent = nullptr;
		}
		//2.parent是子树，需要更改parent的上一层节点的孩子指向
		else
		{
			//判断ppnode指向左还是右
			if (ppnode->_left == parent)
			{
				ppnode->_left = subr;
			}
			else
			{
				ppnode->_right = subr;
			}
			subr->_parent = ppnode;
		}
		subr->_bf = parent->_bf = 0;
	}

	void RotateR(node* parent)
	{
		//这里同左旋转
		node* subl = parent->_left;
		node* sublr = subl->_right;
		node* ppnode = parent->_parent;
		subl->_right = parent;
		parent->_parent = subl;
		parent->_left = sublr;
		if (sublr)
		{
			sublr->_parent = parent;
		}
		if (_root == parent)
		{
			_root = subl;
			subl->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent);
			{
				ppnode->_left = subl;
			}
			else
			{
				ppnode->_right = subl;
			}
			subl->_parent = ppnode;
		}
		subl->_bf = parent->_bf = 0;
	}

	void RotateLR(node* parent)
	{
		node* subl = parent->_left;
		node* sublr = subl->_right;
		int bf = sublr->_bf;
		RotateL(parent->_left);
		RotateR(parent);

		sublr->_bf = 0;
		if (bf == 1)
		{
			parent->_bf = 0;
			subl->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subl->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subl->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	void RotateRL(node* parent)
	{
		node* subr = parent->_right;
		node* subrl = subr->_left;
		int bf = subrl->_bf;
		RotateR(parent->_right);
		RotateL(parent);
		subrl->_bf = 0;
		if (bf == 1)
		{
			subr->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			subr->_bf = 1;
			parent->_bf = 0;
		}
		else if(bf == 0)
		{
			parent->_bf = 0;
			subr->_bf = 0;
		}
	}
};

定义：

AVL树的概念

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查

找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii

和E.M.Landis在1962年

发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右

子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均

搜索长度

特点：

1.它的左右子树都是AVL树

2.左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

更新平衡因子规则：