AVL树（一）

一、AVL树的概念

1、二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。

2、AVL树的特点

（1）当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

（2）左右子树高度之差(简称平衡因子)的绝对值不超过1,平衡因子的求法=右子树高度-左子树的高度

（3）一棵AVL树可以是空树

二、AVL树节点的定义

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

	AVLTreeNode<K,V>* _left;//该节点的左孩子
	AVLTreeNode<K,V>* _right;//该节点的右孩子
	AVLTreeNode<K,V>* _parent;//该节点的父节点
	pair<K,V> _kv;
	int _bf;   // 节点的平衡因子，为右子树高度-左子树高度
};

三、AVL树的插入

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

1. 按照二叉搜索树的方式插入新节点

2. 调整节点的平衡因子

bool Insert(const pair<K,V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;

		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;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		//新结点在parent的左边插入
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
			cur->_parent;
		}
		//新节点在parent的右边插入
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		//更新平衡因子
		while (parent)
		{
			//更新父节点的平衡因子
			if (cur == parent->_left)
			{
				parent->_bf--;//在左边插入，父节点的平衡因子应-1
			}
			else
			{
				parent->_bf++;//在右边插入，父节点的平衡因子应+1
			}
			//查看是否需要向上更新
			if (parent->_bf == 0)
			{
				break;
				//更新后父节点的平衡因子是0，说明之前是1或-1
				//这个时候新插入的节点并不会影响父节点，不需要更新平衡因子
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_parent;
				//这个时候说明在插入之后变成了1或-1，插入前的平衡因子是0
				//此时新插入的节点影响了父亲以上的节点，需要向上更新
			}
			//以下是不满足平衡条件，需要旋转
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

四、AVL树的旋转

1、AVL树的旋转主要分为以下四种：

（1）新节点插入较高左子树的左侧—左左：右单旋

（2）新节点插入较高右子树的右侧—右右：左单旋

（3）新节点插入较高左子树的右侧—左右：先左单旋再右单旋

（4）新节点插入较高右子树的左侧—右左：先右单旋再左单旋

2、新节点插入较高左子树的左侧---左左：右单旋

void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		Node* parentParent = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}

			subL->_parent = parentParent;
		}

		subL->_bf = parent->_bf = 0;
	}

3、新节点插入较高右子树的右侧---右右：左单旋

void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		subR->_left = parent;

		Node* parentParent = parent->_parent;

		parent->_parent = subR;
		if (subRL)
			subRL->_parent = parent;

		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
			{
				parentParent->_left = subR;
			}
			else
			{
				parentParent->_right = subR;
			}

			subR->_parent = parentParent;
		}

		parent->_bf = subR->_bf = 0;
	}

4、新节点插入较高左子树的右侧---左右：先左单旋再右单旋

void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);

		if (bf == 0)
		{
			parent->_bf = subL->_bf = subLR->_bf = 0;
		}
		else if (bf == -1)
		{
			subL->_bf = subLR->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = subLR->_bf = 0;
			subL->_bf = -1;
		}
		else
		{
			assert(false);
		}
	}

5、新节点插入较高右子树的左侧---右左：先右单旋再左单旋

	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == 0)
		{
			// subRL自己就是新增
			parent->_bf = subR->_bf = subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			// subRL的左子树新增
			parent->_bf = 0;
			subRL->_bf = 0;
			subR->_bf = 1;
		}
		else if (bf == 1)
		{
			// subRL的右子树新增
			parent->_bf = -1;
			subRL->_bf = 0;
			subR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}