【C++】AVL树的简单实现

目录

前言：

一、AVL树的性质

二、AVL树基本结构

1、AVL树的节点

三、AVL树的插入

1、平衡因子更新规则

2、左单旋

3、右单旋

4、左右双旋

5、右左双旋

四、AVL树的验证

五、AVL树的性能

---

前言：

AVL树是为了弥补搜索树插入时，效率问题而提出来的一种树形结构

二叉搜索树在搜索时的效率比较高是O(logH)，也就是说搜索树的搜索效率依赖于树的高度，当搜

索树插入数据是有序或者接近有序时，树的高度是N(有N个数据)，搜索效率就会退化到O(N)，因

此要提高搜索树的效率，就是要尽量使树的高度低，AVL树就是一颗高度平衡的二叉搜索树。

---

一、AVL树的性质

AVL树的性质是，它的左右子树都是AVL树，并且左右子树的高度差不超过1

这样就限制了搜索树的高度，AVL树接近完全二叉树，使得它的效率提升

二、AVL树基本结构

1、AVL树的节点

这里我们要保证插入节点之后还是AVL树，而AVL树的定义是左右子树高度差不超过1，所以我们要在每一个节点记录它的左右子树高度差，这也就引出了平衡因子

平衡因子 = 右子树的高度 - 左子树的高度

并且为了方便调整AVL树的高度，还需要记录每个节点的父节点(三叉链)

我们这里直接实现搜索树的K/V模型，所以节点就直接存储pair了

template<class T,class K>
struct AVLTreeNode
{
	AVLTreeNode* _left;
	AVLTreeNode* _right;
	AVLTreeNode* _parent;
	pair<const K, V> _kv;
	int _bf; // Balance factor
};
 

因为K是不能被修改的，所以我们传一个const

三、AVL树的插入

AVL树的插入与二叉搜索树类似，首先要找到插入位置，然后是调整平衡因子，判断是否需要旋转，最后是旋转。旋转主要分为四种情况，左单旋，右单旋，左右双旋，右左双旋

	bool insert(const pair& 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->_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;
		//调整平衡因子+旋转
	}

1、平衡因子更新规则

新增在右，parent->_bf++, 新增在左，parent->_bf--

更新后parent->_bf == 1 or -1，说明在插入之前parent->_bf == 0，说明左右子树高度相同，插入之后左右子树高度不同，需要往上更新平衡因子

更新后，parent->_bf == 0，说明之前parent->_bf == 1  or -1 说明左右子树不一边高，插入后左右子树高度相同，说明插入到了左右子树中矮的那一边，不需要往上更新

更新后parent->_bf == 2 or -2 说明parent插入前的平衡因子是1  or  -1，已经在平衡的临界值，插入之后打破平衡，需要进行旋转

更新之后parent->_bf > 2 or < -2 说明，在插入之前就不是AVL树，需要检查之前的操作

		//调整平衡因子+旋转
		//调整最多是调整到根，根是没有父亲的
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else
			{
				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)
			{
				//开始旋转
			}
			else
			{
				//出错了，按照常理不会出现这种情况
				assert(false);
			}
            break;
		}
		return true;

2、左单旋

假如有这样的一棵树，子树a,b,c都是高度为h的AVL树，现在我们要在c子树插入一个节点

 插入之后更新平衡因子，因为是插入在60的右边，导致60的平衡因子变成1，30的平衡因子变成2，右边高了，所以需要我们进行左旋

具体过程：将cur的左子树给parent的右子树，parent作为cur的左子树

最后是更新平衡因子，因为parent的左右子树高度相同所以parent->_bf == 0

cur的左右子树高度相同，所以也是0

	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		Node* ppNode = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;
		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
		subR->_bf = parent->_bf = 0;
	}

3、右单旋

假如有这样的一棵树，子树a,b,c都是高度为h的AVL树，现在我们要在a子树插入一个节点

a这棵树的高度是h+1,更新平衡因子

发现parent->_bf == -2, cur->_bf == -1，这时候左边高，需要我们将左子树向右边旋转

具体的旋转过程是，先将cur的右子树给parent的左边，然后parent作为cur的右子树

最后是要看平衡因子的更新，对于parent(60这个节点)，它的左右子树高度相同，平衡因子是0

cur的左子树高度等于右子树高度，平衡因子是0 

void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		Node* ppNode = parent->_parent;//记录parent的parent，旋转完成之后链接
		subL->_right = parent;
		parent->_parent = subL;
		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
		//更新bf
		subL->_bf = parent->_bf = 0;
	}

4、左右双旋

接下来是左右双旋，先进行左旋，再进行右旋

 我们要在b的下面插入一个新节点

 

单看30为根的这棵树， 它的右子树高于左子树，所以进行左旋

左旋之后发现左边高，再进行右旋(以60为轴点)

 

 

	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 == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

5、右左双旋

再60的右边插入一个节点

 

这时以90为轴进行右旋

 

接下来以30为轴进行左旋

	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 == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subR->_bf = 1;
		}
		else
		{
			assert(false);
		}
	}

 

四、AVL树的验证

我们要想验证一棵树是否是AVL树，不能够通过观察它的平衡因子，因为旋转之后的平衡因子是我们手动更新的，就好比我既是裁判又是球员，所以这种方式不可靠。

我们选择判断左右子树高度差是否符合条件来判断 + 中序遍历 + 平衡因子

这三种方式叠加来判断

	void InOrder()
	{
		_InOrder(_root);
	}
 
	bool IsBalance()
	{
		return _IsBalance(_root);
	}
	
    void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
 
		_InOrder(root->_left);
		cout << root->_kv.first << " : " << root->_kv.second << endl;
		_InOrder(root->_right);
	}
 
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		int leftDepth = GetDepths(root->_left);
		int rightDepth = GetDepths(root->_right);
		int diff = leftDepth - rightDepth;
		if (diff != root->_bf)
		{
			cout << "平衡因子异常" << endl;
			return false;
		}
		return abs(diff) < 2 
			&& _IsBalance(root->_left) 
			&& _IsBalance(root->_right);
	}
 
	int GetDepths(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		return max(GetDepths(root->_left), GetDepths(root->_right)) + 1;
	}

我们先拿常规测试用例来测试{16, 3, 7, 11, 9, 26, 18, 14, 15}

接下来是特殊场景{4, 2, 6, 1, 3, 5, 15, 7, 16, 14}

 

结果也是没有问题的

最后是拿一组随机值来测试

void test_AVLTree()
{
	srand(time(0));
	AVLTree<int, int> t;
	//{16, 3, 7, 11, 9, 26, 18, 14, 15}
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	/*int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16,14 };
	for (auto it : a)
	{
		t.insert(make_pair(it, it));
	}*/
	size_t N = 10000;
	for (size_t i = 0; i < N; i++)
	{
		int x = rand();
		t.insert(make_pair(x, x));
	}
	t.InOrder();
	cout << t.IsBalance() << endl;
}

 

结果也是没有问题 

五、AVL树的性能