AVL（二叉平衡搜索树）

最新推荐文章于 2025-11-22 23:45:52 发布

原创最新推荐文章于 2025-11-22 23:45:52 发布 · 624 阅读

27 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言

从0开始学习c++ 专栏收录该内容

19 篇文章

订阅专栏

1. AVL的概念

• AVL树是最先发明的⾃平衡⼆叉查找树，AVL是⼀颗空树，或者具备下列性质的⼆叉搜索树：它的左右⼦树都是AVL树，且左右⼦树的⾼度差的绝对值不超过1。AVL树是⼀颗⾼度平衡搜索⼆叉树，通过控制⾼度差去控制平衡。
• AVL树实现这⾥我们引⼊⼀个平衡因⼦(balancefactor)的概念，每个结点都有⼀个平衡因⼦，任何结点的平衡因⼦等于右⼦树的⾼度减去左⼦树的⾼度，也就是说任何结点的平衡因⼦等于0/1/-1，AVL树并不是必须要平衡因⼦，但是有了平衡因⼦可以更⽅便我们去进⾏观察和控制树是否平衡，就像⼀个⻛向标⼀样。
• 思考⼀下为什么AVL树是⾼度平衡搜索⼆叉树，要求⾼度差不超过1，⽽不是⾼度差是0呢？0不是更好的平衡吗？画画图分析我们发现，不是不想这样设计，⽽是有些情况是做不到⾼度差是0的。⽐如⼀棵树是2个结点，4个结点等情况下，⾼度差最好就是1，⽆法做到⾼度差是0
• AVL树整体结点数量和分布和完全⼆叉树类似，⾼度可以控制在logn ，那么增删查改的效率也可以控制在O(logn) ，相⽐⼆叉搜索树有了本质的提升。

2. AVL树的实现

2.1 AVL树的结构

template<class K,class V>
struct AVLtreenode
{
	pair<K, V>_kv;
	AVLtreenode<K, V>* _left;
	AVLtreenode<K, V>* _right;
	// 需要parent指针，后续更新平衡因⼦可以看到 
	AVLtreenode<K, V>* _parents;
	int _bf;//平衡因子

	AVLtreenode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parents(nullptr)
		,_bf(0)

};

template<class K,class V>
class AVLtree
{
	typedef AVLtreenode<K, V>Node;


private:
	Node* _root = nullptr;
};

2.2 AVL树的插⼊
2.2.1 AVL树插⼊⼀个值的⼤概过程

插⼊⼀个值按⼆叉搜索树规则进⾏插⼊。
新增结点以后，只会影响祖先结点的⾼度，也就是可能会影响部分祖先结点的平衡因⼦，所以更新从新增结点->根结点路径上的平衡因⼦，实际中最坏情况下要更新到根，有些情况更新到中间就可以停⽌了，具体情况我们下⾯再详细分析。
更新平衡因⼦过程中没有出现问题，则插⼊结束
更新平衡因⼦过程中出现不平衡，对不平衡⼦树旋转，旋转后本质调平衡的同时，本质降低了⼦树的⾼度，不会再影响上⼀层，所以插⼊结束。

2.2.2 平衡因⼦更新
更新原则：
• 平衡因⼦=右⼦树⾼度-左⼦树⾼度
• 只有⼦树⾼度变化才会影响当前结点平衡因⼦。
• 插⼊结点，会增加⾼度，所以新增结点在parent的右⼦树，parent的平衡因⼦++，新增结点在parent的左⼦树，parent平衡因⼦–
• parent所在⼦树的⾼度是否变化决定了是否会继续往上更新
更新停⽌条件：

更新后parent的平衡因⼦等于0，更新中parent的平衡因⼦变化为-1->0或者1->0，说明更新前parent⼦树⼀边⾼⼀边低，新增的结点插⼊在低的那边，插⼊后parent所在的⼦树⾼度不变，不会影响parent的⽗亲结点的平衡因⼦，更新结束。
更新后parent的平衡因⼦等于1或-1，更新前更新中parent的平衡因⼦变化为0->1或者0->-1，说明更新前parent⼦树两边⼀样⾼，新增的插⼊结点后，parent所在的⼦树⼀边⾼⼀边低，parent所在的⼦树符合平衡要求，但是⾼度增加了1，会影响parent的⽗亲结点的平衡因⼦，所以要继续向上更新。
更新后parent的平衡因⼦等于2或-2，更新前更新中parent的平衡因⼦变化为1->2或者-1->-2，说明更新前parent⼦树⼀边⾼⼀边低，新增的插⼊结点在⾼的那边，parent所在的⼦树⾼的那边更⾼了，破坏了平衡，parent所在的⼦树不符合平衡要求，需要旋转处理，旋转的⽬标有两个：1、把parent⼦树旋转平衡。2、降低parent⼦树的⾼度，恢复到插⼊结点以前的⾼度。所以旋转后也不需要继续往上更新，插⼊结束。
• 不断更新，更新到根，跟的平衡因⼦是1或-1也停⽌了。

2.2.3 插⼊结点及更新平衡因⼦的代码实现

bool insert(const pair<K, V>& kv)
{
	//先找到在哪个位置插入
	if (_root == nullptr)
	{
		_root = new Node(kv);
		return true;
	}
	Node* parents = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_kv.first < kv.first)
		{
			parents = cur;
			cur = cur->_right;
		}
		else if (cur->_kv.first > kv.first)
		{
			parents = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(kv);
	if (parents->_kv.first > kv.first)
	{
		parents->_left = cur;
		cur->_parents = parents;
	}
	else
	{
		parents->_right = cur;
		cur->_parents = parents;
	}

	//更改平衡元素
	while(parents)
	{
		if (parents->_left == cur)
		{
			parents->_bf--;
		}
		else
		{
			parents->_bf++;
		}
		//1.
		if (parents->_bf == 0)
		{
			break;
		}
		//2.
		else if (parents->_bf == 1 || parents->_bf == -1)
		{
			cur = cur->_parents;
			parents = parents->_parents;
		}
		else if (parents->_bf == 2 || parents->_bf == -2)
		{
			//旋转
		}
		else
		{
			assert(false);
		}
    }
	return true;
}

2.3 旋转
2.3.1 旋转的原则

保持搜索树的规则
让旋转的树从不满⾜变平衡，其次降低旋转树的⾼度
旋转总共分为四种，左单旋/右单旋/左右双旋/右左双旋。
2.3.2 右单旋
因为左树的插入导致平衡因子小于-1，此时将插入节点的父节点为根右旋

观察插入后的根节点（parents），根节点的左节点(subl)，以及根节点的左节点的右节点（sublr）的平衡因子以及他们的位置和对应父节点的变化。

void RotateR(Node* parents)
{
	Node* subL = parents->_left;
	Node* subLR = subL->_right;
//1.先变第一个的位置与parents
	parents->_left = subLR;
	if (subLR)//subLR可以为0
		subLR->_parents = parent;
//2.第二个
	Node* parentParent = parents->_parents;

	subL->_right = parents;
	parents->_parents = subL;
// parent有可能是整棵树的根，也可能是局部的⼦树 
 // 如果是整棵树的根，要修改_root 
 // 如果是局部的指针要跟上⼀层链接 
	if (parents == _root)
	{
		_root = subL;
		subL->_parents = nullptr;
	}
	else
	{
		if (parentParent->_left == parent)
		{
			parentParent->_left = subL;
		}
		else
		{
			parentParent->_right = subL;
		}

		subL->_parents = parentParent;
	}

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

2.3.4 左单旋
因为左树的插入导致平衡因子大于1，此时将插入节点的父节点为根左旋
在这里插入图片描述
观察插入后的根节点（parents），根节点的左节点(subr)，以及根节点的左节点的右节点（subrl）的平衡因子以及他们的位置和对应父节点的变化。

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

	parents->_right = subRL;
	if (subRL)
		subRL->_parents = parents;

	Node* parentParent = parents->_parents;

	subR->_left = parents;
	parents->_parents = subR;

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

		subR->_parents = parentParent;
	}

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

2.3.6 左右双旋
在这里插入图片描述
右边高但是其插入的位置在左树，导致其先左旋，解决局部右高又导致整体左高。再次进行右旋
有三种情况（旋转后平衡因子不同）
第一种插入在SUBLR的左子树，观察旋转后三节点（parents，subl，sublr）的位置以及平衡因子
在这里插入图片描述

第二种插入在SUBLR的右子树，观察旋转后三节点（parents，subl，sublr）的位置以及平衡因子
在这里插入图片描述第三种

void RotateLR(Node* parents)
{
	Node* subL = parents->_left;
	Node* subLR = subL->_right;

	int bf = subLR->_bf;

	RotateL(subL);
	RotateR(parents);
//三种不同的情况
	if (bf == 0)
	{
		subL->_bf = 0;
		parents->_bf = 0;
		subLR->_bf = 0;
	}
	else if (bf == 1)
	{
		subL->_bf = -1;
		parents->_bf = 0;
		subLR->_bf = 0;
	}
	else if (bf == -1)
	{
		subL->_bf = 0;
		parents->_bf = 1;
		subLR->_bf = 0;
	}
	else
	{
		assert(false);
	}
}

2.3.8 右左双旋
同理
在这里插入图片描述
第一种

第二种
第三种

void RotateRL(Node* parents)
{
	Node* subR = parents->_right;
	Node* subRL = subR->_left;
	int bf = subRL->_bf;
	RotateR(parents->_right);
	RotateL(parents);
	if (bf == 0)
	{
		subR->_bf = 0;
		subRL->_bf = 0;
		parents->_bf = 0;
	}
	else if (bf == 1)
	{
		subR->_bf = 0;
		subRL->_bf = 0;
		parents->_bf = -1;
	}
	else if (bf == -1)
	{
		subR->_bf = 1;
		subRL->_bf = 0;
		parents->_bf = 0;
	}
	else
	{
		assert(false);
	}
}

2.4 AVL树的查找
那⼆叉搜索树逻辑实现即可，搜索效率为O(logN)

Node* 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;
  }
 }
 return nullptr;
}

2.5 AVL树平衡检测
我们实现的AVL树是否合格，我们通过检查左右⼦树⾼度差的的程序进⾏反向验证，同时检查⼀下结点
的平衡因⼦更新是否出现了问题。

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;
}
bool _IsBalanceTree(Node* root)
{
 // 空树也是AVL树 
 if (nullptr == root)
 return true;
 // 计算pRoot结点的平衡因⼦：即pRoot左右⼦树的⾼度差 
 int leftHeight = _Height(root->_left);
 int rightHeight = _Height(root->_right);
 int diff = rightHeight - leftHeight;
 // 如果计算出的平衡因⼦与pRoot的平衡因⼦不相等，或者 
 // pRoot平衡因⼦的绝对值超过1，则⼀定不是AVL树 
 if (abs(diff) >= 2)
 {
 cout << root->_kv.first << "⾼度差异常" << endl;
 return false;
 }
 if (root->_bf != diff)
 {
 cout << root->_kv.first << "平衡因⼦异常" << endl;
 return false;
 }
 // pRoot的左和右如果都是AVL树，则该树⼀定是AVL树 
 return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
}