AVL树详解与总结

前言：

什么叫做AVL树？

    AVL树的定义：

1、AVL的左右子树高度之差的绝对值不超过1；

2、树中的左右子树都为AVL树

3、平衡因子只能是（-1、0、1）

    AVL树的效率

AVL树的总共节点为N个，他的高度能搞保持在logN,插入、删除、查找等操作的时间复杂度也是logN。

    AVL树的实现：

1、AVL树的插入：

思路分析：1> 既然是插入就需要先找到插入的位置，使用while循环遍历找到插入位置

                   2> 找到插入位置以后直接插入，然后向上遍历修改父节点的平衡因子，当修改完以后的平衡因子有等于2或者-2的挑出来，进行树的旋转，并且调整平衡因子，使满足AVL树的定义。

                   3> 旋转过程中需要考虑是左旋转、右旋转、左右旋转、还是右左旋转。左右旋转简单，直接调用自己编写的左右旋转函数即可，只要传过来的节点记得加上引用就行了，这样能够直接连接到旋转后的子树。重点在于左右和右左旋转，我们是否能直接调用左旋转函数和右旋转函数各一次？答案是否定的，因为在旋转的过程中，不是在插入的那个位置进行旋转，而是在中间进行旋转，这是后父亲节点和祖父节点的平衡因子BF就需要自己手动来定义了。以右左旋转来分析：

如果当前节点的平衡因子为-1，那么他的parent应该为1，pparent应该为0；

如果当前节点的平衡因子为1，那么他的parent应该为0，pparent应该为-1；

如果当前节点的平衡因子为0，那么他的parent应该为0，pparent应该为0；

具体自己下去画个图，在插入节点的位置（cur）下面加一个左节点或者右节点，然后分析。

#ifndef __BALANCETREE_H__
#define __BALANCETREE_H__

template<class K,class V>
struct BLNode
{
	K _key;
	V _value;
	BLNode<K, V>* _left;
	BLNode<K, V>* _right;
	BLNode<K, V>* _parent;
	int _bf;

	BLNode(const K& key, const V& value)
		:_key(key)
		, _value(value)
		, _parent(NULL)
		, _left(NULL)
		, _right(NULL)
		, _bf(0)
	{}

};

template<class K,class V>
class BalanceTree
{
	typedef BLNode<K, V> Node;

public:
	BalanceTree()
		:_root(NULL)
	{}

	bool Insert(const K& key, const V& value)
	{
		//先查找需要插入的位置
		if (_root == NULL)
		{
			_root = new Node(key, value);
			return true;
		}

		Node* parent = NULL;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}

		//找到插入位置以后,确定平衡因子
		Node* ppNode = parent->_parent;
		

		if (parent->_key > key)//找到插入位置以后判断是在父节点的左边还是右边，插入以后先调整平衡因子，向上遍历，如果本来是-1或者1插入以后为0就不用调整了，因为上一层看到的还是这一层的高度没有变
		{
			cur = new Node(key, value);
			parent->_left = cur;
			cur->_parent = parent;
			parent->_bf--;
			while (parent)
			{
				if ((parent->_bf == -1 ||parent->_bf ==1)&& parent->_parent != NULL)
				{
					if (parent->_parent->_key >parent->_key)
						parent->_parent->_bf--;
					else if (parent->_parent->_key < parent->_key)
						parent->_parent->_bf++;
					if (parent->_parent->_bf == 2 || parent->_parent->_bf == -2)
						break;
					cur = parent;
					parent = parent->_parent;
				}
				else
					break;
			}
			
		}

		else if (parent->_key < key)
		{
			cur = new Node(key, value);
			parent->_right = cur;
			cur->_parent = parent;
			parent->_bf++;
			while (parent)
			{
				if ((parent->_bf == 1 ||parent->_bf == -1)&& parent->_parent != NULL)
				{
					if (parent->_parent->_key >parent->_key)
						parent->_parent->_bf--;
					else if (parent->_parent->_key < parent->_key)
						parent->_parent->_bf++;
					if (parent->_parent->_bf == 2 || parent->_parent->_bf == -2)
						break;
					cur = parent;
					parent = parent->_parent;
				}
				else
					break;
			}
		}

		//根据平衡因子的变动，开始调整当前的树，因为刚刚是平衡因子不符合的时候跳出来的
		ppNode = parent->_parent;
		Node* pppNode = NULL;
		if (ppNode!=NULL)
			pppNode = ppNode->_parent;
		if (ppNode && (ppNode->_bf == 2 || ppNode->_bf == -2))
		{
			//左旋
			if (parent == ppNode->_right && parent->_right == cur)
			{
				RotateL(ppNode);
			}

			//右旋
			else if (ppNode->_left == parent && parent->_left == cur)
			{
				RotateR(ppNode);
			}

			//左右双旋
			else if (ppNode->_left == parent &&parent->_right == cur)
			{
				int bf = cur->_bf;
				Node* pNode = ppNode;
				Node* pLeftNode = parent;
				RotateL(parent);//先左旋，再链接
				ppNode->_left = parent;
				RotateR(ppNode);

				if (bf == 0)
				{
					pNode->_bf = 0;
					pLeftNode->_bf = 0;
				}
				else if (bf == -1)
				{
					pNode->_bf = 1;
					pLeftNode->_bf = 0;
				}
				else if (bf == 1)
				{
					pNode->_bf = 0;
					pLeftNode->_bf = -1;
				}
			}

			//右左双旋
			else if (ppNode->_right == parent &&parent->_left == cur)
			{
				int bf = cur->_bf;
				Node* pNode = ppNode;
				Node* pRightNode = parent;
				RotateR(parent);
				ppNode->_right = parent;
				RotateL(ppNode);

				if (bf == 0)
				{
					pNode->_bf = 0;
					pRightNode->_bf = 0;
				}
				else if (bf == -1)
				{
					pNode->_bf = 0;
					pRightNode->_bf = 1;
				}
				else if (bf == 1)
				{
					pNode->_bf = -1;
					pRightNode->_bf = 0;
				}
			}

			if (pppNode == NULL)
			{
				_root = ppNode;
			}
			else
			{
				if (pppNode->_key > ppNode->_key)
					pppNode->_left = ppNode;
				else if (pppNode->_key < ppNode->_key)
					pppNode->_right = ppNode;
			}

		}
	}


	size_t Height()
	{
		return _Height(_root);
	}
	
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

protected:
	size_t _Height(Node* root)
	{
		if (root == NULL)
			return 0;

		return _Height(root->_left) > _Height(root->_right) ? _Height(root->_left) + 1 : _Height(root->_right) + 1;
	}
	void _InOrder(Node* root)
	{
		if (root == NULL)
			return;

		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

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

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

		parent->_right = subRL;
		if (subRL != NULL)
			subRL->_parent = parent;

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

		parent = subR;
	}

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

		parent->_right = subRL;
		if (subRL != NULL)
			subRL->_parent = parent;

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

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

		parent = subR;
	}

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

		parent->_left = subLR;
		if (subLR != NULL)
			subLR->_parent = parent;

		subL->_parent = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		parent->_bf = 0;
		subL->_bf = 0;

		parent = subL;
	}



protected:
	Node* _root;
};




void test()
{
	BalanceTree<int, int> bt;
	int arr[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		bt.Insert(arr[i], i);
	}

	bt.InOrder();
	cout << bt.Height() << endl;

	BalanceTree<int, int> bt1;
	int arr1[] = { 4,2,6,1,3,5,15,7,16,14 };
	for (int i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
	{
		bt1.Insert(arr1[i], i);
	}

	bt1.InOrder();
	cout << bt1.Height() << endl;
}


#endif //__BALANCETREE_H__

2、AVL树的删除：

    删除相对而言跟插入差不多，都是需要理解过程的，对于删除，我们只需要先找到要删除的位置，然后分为三种情况：

1.左为空-------->直接连接到父节点上，只是需要判断连接到父节点的左还是右上

2.右为空-------->同上

3.左右都不为空：找到右边子树的最左节点，（这里还分为两种情况：没有左子节点和有）这里只分析有左子节点的了，一直往左遍历找到左子节点，交换左子节点和要删除的节点，然后将parent->left连到左子节点的右就行了，最后一步就是调节平衡因子了，从当前节点开始向上修改平衡因子，以及判断平衡因子有没有为2或者-2的情况，然后跟上面一样做处理。