AVL树的概念与实现

概念

AVL树的概念

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

特点

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

• 它的左右子树都是AVL树
• 左右子树高度之差(简称平衡因子)的绝对值不超过1
• 如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 ，O(log2n)搜索时间复杂度O(log2n)。

实现

AVL树节点定义

相比搜索树多了一个父亲节点与平衡因子，平衡因子只能是-1 0 1。

template<class T>
struct AVLTreeNode {
	AVLTreeNode(const T& k) 
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_data(k)
		,_bf(0)
	{}
	AVLTreeNode<T>* _left;
	AVLTreeNode<T>* _right;
	AVLTreeNode<T>* _parent;
	T _data;
	int _bf;
};

AVL树的插入

AVL树相比于普通搜索树，多了一个平衡因子。
因此插入分为两步：

• 按照搜索树规则进行插入
• 更新平衡因子

bool Insert(const T& k) {
		if (_root == nullptr) {//空树直接创建
			_root = new Node(k);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (cur->_data > k) {
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_data < k) {
				parent = cur;
				cur = cur->_right;
			}
			else {//相等不插入
				return false;
			}
		}
		//找到空位置 创建节点进行插入
		cur = new Node(k);
		if (parent->_data > k) {
			parent->_left = cur;
		}
		else {
			parent->_right = cur;
		}
		cur->_parent = parent;//三叉链还得更新父亲
		while (parent) {
			if (cur == parent->_left) {
				parent->_bf--;
			}
			else {
				parent->_bf++;
			}
			if (parent->_bf == 0) {//说明平衡因子只对当前parent造成改变，并不影响上层
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1) {//从0到-1 1 因此改变了该路径上的平衡因子 
				//向上迭代及进行平衡因子的更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2){//不平衡出现了需要进行旋转
				if (parent->_bf == 2) {
					if (cur->_bf == 1) {
						RotateL(parent);
					}
					else if (cur->_bf == -1) {
						RotateRL(parent);
					}
				}
				else if (parent->_bf == -2) {
					if (cur->_bf == -1) {
						RotateR(parent);
					}
					else if (cur->_bf == 1) {
						RotateLR(parent);
					}
				}
			}
		}
	}

AVL树的旋转

当平衡因子成为-2 / 2 时 就需要进行旋转处理从而使这棵AVL树重新变成平衡搜索二叉树。
AVL的旋转针对不同的情况一共有四种。

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

下面对四种方式进行逐一说明：

右单旋一句话概括就是 parent成为它左孩子节点的右孩子节点，它的左孩子节点的右孩子节点成为了parent的左孩子节点

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

		parent->_parent = subL ;
		subL->_left = parent;

		parent->_left = subLR;
		if (subLR != nullptr) {
			subLR->_parent = parent;
		}
		subL->_parent = pparent;
		if (pparent == nullptr) {//根节点
			_root = subL;
		}
		if (pparent->_left == parent) {
			pparent->_left = subL;
		}
		else {
			pparent->_right = subL;
		}
		subL->_bf = parent->_bf = 0;//更新平衡因子
	}

左单旋和右单旋类似

void RotateL(Node* parent) {//左单旋针对的是最最最右边不平衡
		//需要将父节点的右子树更新成根节点
		//并将该右子树的左子树成为父节点新的右子树
		//跟新其余相关节点即可
		Node* subL = parent->_left;
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* pparent = parent->_parent;

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

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

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

左右旋和右左旋转相似这里给出左右旋转

void RotateLR(Node* parent) {
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;
		RotateL(subL);
		RotateR(parent);

		if (bf == 1) {
			parent->_bf = 0;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		else if (bf == -1) {
			parent->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else {
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
	}

AVL树的查找

AVL树的查找和普通搜索二叉树类似。这里不加赘述。
但是相较于性能就有了一定程度的提升，AVL树因为有平衡因子的控制导致不会有单支树的极端情况出现，在任意时刻查找的时间复杂度都是O(log2N).