AVL树的c++实现

AVL树的c++实现

1.概念

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

它的左右子树都是AVL树 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 ，搜索时 间复杂度O( )。

2. 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; // 该节点的平衡因子
 };

3.AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入 过程可以分为两步： 1. 按照二叉搜索树的方式插入新节点 2. 调整节点的平衡因子

bool Insert(const T& data)
{
 /*
 1. 先按照二叉搜索树的规则将节点插入到AVL树中
 2. 新节点插入后，AVL树的平衡性可能会遭到破坏，此时就需要更新平衡因子，并检测是否破坏了AVL树的平衡性
 pCur插入后，pParent的平衡因子一定需要调整，在插入之前，pParent
 的平衡因子分为三种情况：-1，0, 1, 分以下两种情况：
 1. 如果pCur插入到pParent的左侧，只需给pParent的平衡因子-1即可
 2. 如果pCur插入到pParent的右侧，只需给pParent的平衡因子+1即可
 
 此时：pParent的平衡因子可能有三种情况：0，正负1， 正负2
 1. 如果pParent的平衡因子为0，说明插入之前pParent的平衡因子为正负1，插入后被调整成0，此
时满足
 AVL树的性质，插入成功
 2. 如果pParent的平衡因子为正负1，说明插入前pParent的平衡因子一定为0，插入后被更新成正负
1，此
 时以pParent为根的树的高度增加，需要继续向上更新
 3. 如果pParent的平衡因子为正负2，则pParent的平衡因子违反平衡树的性质，需要对其进行旋转
处理
 */
     while (pParent)
     {
     // 更新双亲的平衡因子
         if (pCur == pParent->_pLeft)
         	pParent->_bf--;
         else
         	pParent->_bf++;
         // 更新后检测双亲的平衡因子
         if (0 == pParent->_bf)
         	break;
         else if (1 == pParent->_bf || -1 == pParent->_bf)
         {
             // 插入前双亲的平衡因子是0，插入后双亲的平衡因为为1 或者 -1 ，说明以双亲为根的二叉树
             // 的高度增加了一层，因此需要继续向上调整
             pCur = pParent;
             pParent = pCur->_pParent;
         }
         else
         {
             // 双亲的平衡因子为正负2，违反了AVL树的平衡性，需要对以pParent
             // 为根的树进行旋转处理
             if(2 == pParent->_bf)
             {
                 // ...
             }
             else
             {
    			// ...
     		}
     	}
     }
     return true;
}

4.AVL树的旋转

如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，使之平衡 化。根据节点插入位置的不同，AVL树的旋转分为四种：

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

   

/*
 上图在插入前，AVL树是平衡的，新节点插入到1的左子树(注意：此处不是左孩子)中，1左子树增
加
 了一层，导致以2为根的二叉树不平衡，要让2平衡，只能将2左子树的高度减少一层，右子树增加
一层，
 即将左子树往上提，这样2转下来，因为2比1大，只能将其放在1的右子树，而如果1有右子
树，右子树根的值一定大于1，小于2，只能将其放在2的左子树，旋转完成后，更新节点的平衡因子
即可。在旋转过程中，有以下几种情况需要考虑：
 1. 1节点的右孩子可能存在，也可能不存在
 2. 2可能是根节点，也可能是子树
 如果是根节点，旋转完成后，要更新根节点
 如果是子树，可能是某个节点的左子树，也可能是右子树
 
同学们再此处可举一些详细的例子进行画图，考虑各种情况，加深旋转的理解
*/
void _RotateR(PNode pParent)
{
     // pSubL: pParent的左孩子
     // pSubLR: pParent左孩子的右孩子，注意：该
     PNode pSubL = pParent->_pLeft;
     PNode pSubLR = pSubL->_pRight;
     // 旋转完成之后，1的右孩子作为双亲的左孩子
     pParent->_pLeft = pSubLR;
     // 如果1的左孩子的右孩子存在，更新亲双亲
     if(pSubLR)
     pSubLR->_pParent = pParent;
     // 2 作为 1的右孩子
     pSubL->_pRight = pParent;	
    // 因为2可能是棵子树，因此在更新其双亲前必须先保存2的双亲
     PNode pPParent = pParent->_pParent;

     // 更新2的双亲
     pParent->_pParent = pSubL;

     // 更新1的双亲
     pSubL->_pParent = pPParent;
     // 如果2是根节点，根新指向根节点的指针
     if(NULL == pPParent)
     {
     _pRoot = pSubL;
     pSubL->_pParent = NULL;
     }
     else
     {
     // 如果2是子树，可能是其双亲的左子树，也可能是右子树
     if(pPParent->_pLeft == pParent)
     pPParent->_pLeft = pSubL;
     else
     pPParent->_pRight = pSubL;
     }
     // 根据调整后的结构更新部分节点的平衡因子
     pParent->_bf = pSubL->_bf = 0;
}

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

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

   

将双旋变成单旋后再旋转，即：先对30进行左单旋，然后再对90进行右单旋，旋转完成后再考虑平衡因 子的更新。

// 旋转之前，2的平衡因子可能是-1/0/1，旋转完成之后，根据情况对其他节点的平衡因子进行调整
void _RotateLR(PNode pParent)
{
     PNode pSubL = pParent->_pLeft;
     PNode pSubLR = pSubL->_pRight;

     // 旋转之前，保存pSubLR的平衡因子，旋转完成之后，需要根据该平衡因子来调整其他节点的平
    衡因子
     int bf = pSubLR->_bf;

     // 先对1进行左单旋
     _RotateL(pParent->_pLeft);

     // 再对3进行右单旋
     _RotateR(pParent);
     if(1 == bf)
     pSubL->_bf = -1;
     else if(-1 == bf)
     pParent->_bf = 1;
}

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

参考右左双旋。 总结： 假如以pParent为根的子树不平衡，即pParent的平衡因子为2或者-2，分以下情况考虑 1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR 当pSubR的平衡因子为1时，执行左单旋 当pSubR的平衡因子为-1时，执行右左双旋 2. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL 当pSubL的平衡因子为-1是，执行右单旋 当pSubL的平衡因子为1时，执行左右双旋 旋转完成后，原pParent为根的子树个高度降低，已经平衡，不需要再向上更新。

5.AVL的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证 查询时高效的时间复杂度，即 。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如： 插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。 因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树， 但一个结构经常修改，就不太适合。

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	pair<K, V> _kv;

	int _bf; // balance factor

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

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	AVLTree()
		:_root(nullptr)
	{}

	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;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		// 控制平衡
		// 1、更新平衡因子 -- 新增节点到根节点的祖先路径
		// 2、出现异常平衡因子，那么需要旋转平衡处理
		while (parent)
		{
			if (cur == parent->_left)
				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->_bf == -1)
				{
					RotateR(parent);
				}
				else 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
				{
					assert(false);
				}

				break;
			}
			else
			{
				// 说明插入更新平衡因子之前，树中平衡因子就有问题了
				assert(false);
			}
		}

		return true;
	}

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

		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}

		Node* parentParent = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;

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

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

	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 (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
				parentParent->_left = subL;
			else
				parentParent->_right = subL;

			subL->_parent = parentParent;
		}

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

	void RotateLR(Node* parent)
	{
		RotateL(parent->_left);
		RotateR(parent);
	}

	void RotateRL(Node* parent)
	{
		RotateR(parent->_right);
		RotateL(parent);
	}
private:
	Node* _root;
};