C++：AVL树(平衡二叉树)

引言：

AVL树是一种特殊的二叉搜索树，二叉搜索树虽然可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

一棵AVL树具有如下性质：

• 左右子树都是AVL树
• 左右子树高度差绝对值不超过1

 一、AVL树结点的定义

 

template<class T>
struct AVLTreeNode
{
AVLTreeNode(const T& data)
  : _pLeft(nullptr), _pRight(nullptr), _pParent(nullptr)
, _data(data), _bf(0)
{}
AVLTreeNode<T>* _pLeft;  // 该节点的左孩子
AVLTreeNode<T>* _pRight;  // 该节点的右孩子
AVLTreeNode<T>* _pParent; // 该节点的双亲
T _data;
int _bf;          // 该节点的平衡因子
};

二、AVL树的插入

 与普通的二叉搜索树不同，AVL树在数据插入后需要维护整棵树的平衡，并且更新结点的平衡因子

AVL树的插入过程可以分为两步： 

1. 按照二叉搜索树的方式插入新节点
2. 调整节点的平衡因子

bool Insert(const T& data)
	{
        //如果是空树，直接插入并结束
		if (_pRoot == nullptr)
		{
			_pRoot = new Node(data);
			return true;
		}
        

        //这一块代码的目的是找到插入位置的父亲结点
		Node* parent = nullptr;
		Node* cur = _pRoot;
		while (cur)
		{
			if (data < cur->_data)
			{
				parent = cur;
				cur = cur->_pLeft;
			}
			else if (data > cur->_data)
			{
				parent = cur;
				cur = cur->_pRight;
			}
			else
			{
				return false;
			}
		}



		if (cur == parent->_pLeft)
		{
			cur = new Node(data);
			parent->_pLeft = cur;
		}
		else
		{
			cur = new Node(data);
			parent->_pRight = cur;
		}
		//从parent结点开始向上更新祖先的平衡因子
		while (parent)
		{
			if (parent->_bf == 0)
			{
				break;//插入之后，该结点平衡因子为0说明以该结点为根的子树平衡了
                      //且插入前后高度不变，所以这个结点的祖先的平衡因子不会受到影响，结束
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
                //平衡因子从0变为1或者-1，祖先可能变成2或-2，需要继续向上更新
				cur = parent;
				parent = parent->_pParent;
			}
			else
			{
                //结点的平衡因子变成了2或者-2，需要进行旋转了
                //这里开始需要对AVL树进行旋转，之后再讲
				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)
				{
					RotateRL(parent);
				}
				else
				{
					RotateLR(parent);
				}
				break;
			}
		}
		return true;
	}

三、AVL树的旋转

1.右单旋

 

 

这是一幅抽象图，左子树较高且在左子树的左侧插入 ,`h>=0,此时需要进行右单旋

 我们可以看到这样旋转之后该子树依然是一个二叉搜索树，巧妙的是，根节点的平衡因子被更新  成0了，这说明：在旋转之后不用再对祖先更改平衡因子了

 

void RotateR(Node* pParent)
	{
		Node*subL = pParent->_pLeft;
		Node* subLR = subL->_pRight;
		pParent->_pLeft = subRL;
		if (subLR)
		{
			subLR->_pParent = pParent;
		}
		Node*parentParent = pParent->_pParent;
		subL->_pRight = pParent;
		if (pRoot == pParent)
		{
			pRoot = subL;
			subL->_pParent = nullptr;
		}
		else
		{
			if (parentParent->_pLeft == pParent)
			{
				parentParent->_pLeft = subL;
			}
			else
			{
				parentParent->_pRight = subL;
			}
			subL->_pParent = parentParent;
		}
		pParent->_bf = subL->_bf = 0;
	}

2.左单旋

 左单旋和右单旋类似，只是方向相反，右子树较高且在右子树的右侧插入

void RotateL(Node* pParent)
	{
		Node*subR = pParent->_pRight;
		Node* subRL = subR->_pLeft;
		pParent->_pRight = subRL;
		if (subRL)
		{
			subRL->_pParent = pParent;
		}
		Node* parentParent = pParent->_pParent;
		pParent->_pParent = subR;
		subR->_pLeft = pParent;
		if (parent == pRoot)
		{
			pRoot = subR;
			subR->_pParent = nullptr;
		}
		else
		{
			if (parentParent->_pLeft = pParent)
			{
				parentParent->_pLeft = subR;
			}
			else
			{
				parentParent->_pRight = subR;
			}
		}
		pParent->_bf = subR->_bf = 0;
	}

 

3. 左右双旋

 对于单侧插入，只需要旋转一次。但是对于如下的情况，单次旋转无法解决问题

和单旋不同，我们需要对子树再往下画一层，如图所示

这棵树的左子树较高，并且在左子树的右子树插入，导致单旋无法一次解决

旋转过程 

 step1：

step2： 

 

新插入结点无论插入在subLR的左还是右， 最终subLR平衡因子为0

 

// 左右双旋
	void RotateLR(Node* pParent)
	{
		Node* subL = pParent->_pLeft;
		Node* subLR = pParent->_pRight;
		int bf = subLR->_bf;
		RotateL(subL);
		RotateR(pParent);
		//subLR就是新插入结点
		if (bf == 0)
		{
			pParent->_bf = subL->_bf = subLR->_bf = 0;
		}
		else if (bf == 1)
		{
			pParent->_bf = -1;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		else if(bf==-1)
		{
			pParent->_bf = 1;
			subL->_bf = 1;
			subLR = 0;
		}
	}

4.右左双旋

 与左右双旋类似

 

//右左双旋
void RotateRL(Node* pParent)
	{
		Node* subR = pParent->_pRight;
		Node* subRL = subR->_pLeft;
		int bf = subRL->_bf;
		RotateR(subR);
		RotateL(pParent);
		//subRL就是新插入结点
		if (bf == 0)
		{
			pParent->_bf = subR->_bf = subRL->_bf = 0;
		}
		else if (bf == 1)
		{
			pParent->_bf = 0;
			subR->_bf = -1;
			subRL->_bf = 0;
		}
		else if(bf==-1)
		{
			pParent->_bf = 1;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
	}