从C++开始的编程生活（20）——AVL树

前言

本系列文章承接C++基础的学习，需要++有C语言的基础++ 才能学会哦~

第20篇主要讲的是有关于C++的++AVL树++ 。
C++才起步，都很简单！！

目录

前言

AVL树概念

AVL树的插入

平衡因子更新原则

平衡因子更新停止条件

旋转处理图解

目标

原则

右单旋

左单旋

左右双旋

右左双旋

AVL树的模拟实现

---

AVL树概念

AVL树是一颗高度平衡二叉树，通过控制高度差去控制平衡，其左右子树的高度差不超过1。

**平衡因子：**二叉搜索树的每一个结点都有一个平衡因子，平衡因子 = 右子树高度 - 左子树高度。
++当平衡因子∈ -1, 0, 1 时，该二叉搜索树为AVL树。++

因为AVL树的均衡分布，所以增删查改的效率也能控制在O(logN)，相比二叉搜索树有明显上升。

图为AVL树，蓝色数字为平衡因子。

AVL树的插入

后称为++bf（balance factor）++。

①先按照二叉搜索树的规则进行插入。

②新增结点之后可能会影响祖先结点的bf。

平衡因子更新原则

Ⅰ.bf = 右子树高度 - 左子树高度

Ⅱ.只有子树高度变化才会影响当前结点的bf。

Ⅲ.插入结点，会增加高度：若新增在parent的右子树，parent的bd++；若新增在parent的左子树，parent的平衡因子--。

平衡因子更新停止条件

Ⅰ.更新后parent的 bf = 0 ，说明更新前parent的 bf = 1 或 -1，更新前一高一低，新结点插入在低的那边，++插入后parent子树所在的子树高度不变++ ，所以不影响parent的bf，更新结束。

Ⅱ.更新后parent的bf = 1 或 -1，说明更新前其 bf = 0，即其两边子树高度相同，新增结点之后，虽然 bf 仍然符合要求，++但是高度增加了 1++ ，所以要向上更新。

Ⅲ.更新后parent的 bf = 2 或 -2，说明更新前其bf = 1 或 -1，即原本其两边子树就一高一低，新增的结点还加在高的一边，破坏了平衡，所以要进行旋转处理，旋转后不需要继续向上更新。

Ⅳ.++不断更新，更新到根，根的 bf = 1 或 -1 就停止++。

旋转处理图解

目标

1、把parent子树旋转平衡。2、降低parent子树的高度，使其恢复原来的高度。3、旋转前后都是AVL树。

原则

旋转分为右单旋/左单旋/左右双旋/右左双旋

右单旋

Ⅰ.

这是高度为h+2(h≥2)的AVL树，其中a，b，c为这个AVL树的AVL子树，

当我们在a中插入一个新结点，使得a子树高度＋1 ，

Ⅱ.

此时，根结点 bf 变为 -2，21结点 bf 变为 -1，AVL树高度变为h+3

进行右单旋处理，以 33 为旋转点进行右单旋，

Ⅲ.

此时21变为根结点，33变为21的右结点，b子树变为33的左子树。

右单旋完成，AVL树高度变回h+2，且再次回归平衡。

左单旋

是右单旋的镜像操作，逻辑完全一样。

Ⅰ.

这是高度为h+2(h≥2)的AVL树，其中a，b，c为这个AVL树的AVL子树，

当我们在a中插入一个新结点，使得a子树高度＋1 ，

Ⅱ.

此时，根结点 bf 变为 2，21结点 bf 变为 1，AVL树高度变为h+3

进行左单旋处理，以 21 为旋转点进行左单旋，

Ⅲ.

此时33变为根结点，21变为33的左结点，b子树变为33的右子树。

左单旋完成，AVL树高度变回h+2，且再次回归平衡。

左右双旋

Ⅰ.

同样的AVL树，

当我们在b子树中插入一个新结，使得b子树高度 + 1，

Ⅱ.

此时，根结点 bf 变为 -2，21结点 bf 变为 1，AVL树高度变为h+3

进行左右单旋处理，先拆解b子树为，b子树根结点（此处以25为例，视实际情况而定）和e、f子树

Ⅲ.

此处新结点插入e子树(插入f子树,只影响最终平衡因子的结果)。

再以21为旋转点进行左单旋，此次左单旋不需要达到平衡。

Ⅳ.

(插入在e子树)(插入在f子树)

接着以33为旋转点进行右单旋，此次旋转后达到平衡。

Ⅴ.

(插入在e子树)(插入在f子树)

可见不管新结点插入在e子树还是f子树，不会影响达到平衡。

最后一步旋转可以把21结点和a、e(f)子树看为一个整体。

右左双旋

同上，右左双旋为左右双旋的镜像操作。（略）

AVL树的模拟实现

#include<iostream>
#include<assert.h>
using namespace std;

template <class K, class V>
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;//平衡因子

	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_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* 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);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		cur->_parent = parent;

		//更新平衡因子
		while (parent)
		{
			//先更新
			if (cur == parent->_right)
			{
				parent->_bf++;
			}
			else
			{
				parent->_bf--;
			}
			//判断是否要往上更新

			if (parent->_bf == 0)//结束更新
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)//继续往上更新
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)//旋转处理
			{
				//旋转操作
				if (parent->_bf == -2 && cur == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur == 1)
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur == 1)
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur == -1)
				{
					RotateRL(parent);
				}
				else
				{
					assert(false);
				}
				break;
			}
			else
			{
				assert(false);
			}
		}

		return true;
	}

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

		parent->_left = subLR;
		//b子树可能为空
		if (subLR)
		{
			subLR->_parent = parent;//为空就不用考虑subLR的parent指针了
		}
		
		Node* ppNode = parent->_parent;

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

		//若parent为根结点
		if (parent == _root)
		{
			_root = subL;//b子树成为根
			subL->_parent = nullptr;//根的parent为空
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left == subL;
			}
			else
			{
				ppNode->_right == subL;
			}
			subL->_parent = ppNode;
		}

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

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

		parent->_right = subRL;
		//b子树可能为空
		if (subRL)
		{
			subRL->_parent = parent;//为空就不用考虑subRL的parent指针了
		}

		Node* ppNode = parent->_parent;

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

		//若parent为根结点
		if (parent == _root)
		{
			_root = subR;//b子树成为根
			subR->_parent = nullptr;//根的parent为空
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left == subR;
			}
			else
			{
				ppNode->_right == subR;
			}
			subR->_parent = ppNode;
		}

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

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

		RotateL(parent->_left);//先左旋父结点的左孩子
		RotateR(parent);//再右旋父结点

		//插入到e子树
		if (bf == -1)
		{
			subL->_bf = 0;
			parent->_bf = 1;
			subLR->_bf = 0;
		}
		//插入到f子树
		else if (bf == 1)
		{
			subL->_bf = -1;
			parent->_bf = 0;
			subLR->_bf = 0;
		}
		//a、b、c都是空树
		else if(bf == 0)
		{
			subL->_bf = 0;
			parent->_bf = 0;
			subLR->_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);//再左旋父结点

		//插入到e子树
		if (bf == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
		//插入到f子树
		else if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
			subRL->_bf = 0;
		}
		//a、b、c都是空树
		else if (bf == 0)
		{
			subR->_bf = 0;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	void IsBalanceTree()
	{
		_IsBalanceTree(_root);
	}

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

	int Size()
	{
		return _Size(_root);
	}

	void 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;
			}
		}
	}

private:
	int _Size(Node* root)
	{
		if (root == nulptr)
		{
			return 0;
		}
		return _Size(root->_left) + _Size(root->_right) + 1;
	}

	bool _IsBalanceTree(Node* root)
	{
		if (nullptr == root)
		{
			return true;
		}

		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);
		int diff = rightHeight - leftHeight;

		if (abs(diff) >= 2)
		{
			cout << root->_kv.first << "高度差异常" << endl;
			return(false);
		}
		if (root->_bf != diff)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}
		return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

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

	Node* _root = nullptr;
};

❤~~本文完结！！感谢观看！！接下来更精彩！！欢迎来我博客做客~~❤