目录

概述

算法

左单旋

右单旋

左右双旋

右左双旋

源码

AVLTree.h

test.cpp

---

概述

AVL树也叫平衡二叉搜索树，是二叉搜索树的进化版，设计是原理是弥补二叉搜索树的缺陷：当插入的数据接近于有序数列时，二叉搜索树的性能严重下降。

AVL的节点设计采用三叉链结构(每个节点包含left, right, parent三个节点指针)，每个节点中都有平衡因子bf。

AVL的特点是左子树和右子树高度差 < 2，平衡因子bf就是右子树高度 - 左子树高度的差，当bf等于2时，AVL将根据不同情况进行旋转调节，使其始终保持AVL树的特性。

算法

AVL树的节点插入遵循搜索二叉树原则，即左节点一定小于根节点，右节点一定大于根节点，左子树所有节点一定小于根结点，右子树所有节点一定大于根节点。

AVL树的节点插入时，首先根据搜索二叉树原则，找到需要插入节点的位置，插入新节点后，从插入的新节点处向上循环更新平衡因子，若父节点的平衡因子变为0，说明父节点的左右子树高度一样，跳出循环；若父节点的平衡因子为1或-1，则继续向上更新平衡因子，直到父节点变为nullptr再跳出循环；若父节点的平衡因子为2或-2，需要根据平衡因子情况采用不同的旋转调整策略。

AVL树的旋转调整策略一共有4种，分别是：左单旋、右单旋、左右双旋、右左双旋。

左单旋

若数列 1,2,3 按顺序插入AVL树，则树的结构为图1：

图1 中，parent节点的平衡因子bf为2，新节点向上调节时的cur节点的平衡因子为1，这种情况需要左单旋：cur节点的左子数（空）变成parent节点的右子树，parent节点变成cur节点的左子树。

右单旋

右单旋与左单旋类似，也是根据平衡因子情况进行旋转调整。

图1 新节点1插入，向上调整平衡因子，出现parent->bf == -2, cur->bf == -1，此时需要右单旋：cur节点的右子树变为parent节点的左子树，parent变成cur节点的右子树

左右双旋

左右双旋在设计上可以调用左单旋和右单旋函数，但是需要不同情况讨论旋转后的平衡因子

图1 新插入节点0后，parent->bf == -2, cur->bf == 1，此时需要左右双旋，即先以节点-1为父节点进行一次左单旋，再以1为父节点进行一次左单旋：节点0的左子树（空）变成节点-1的左子树，节点-1变成节点0的左子树

图2 完成左单旋之后再以1位父节点进行一次右单旋：节点0的右子树（空）变成节点1的左子树，节点1变成节点0的右子树

图3 此时已经完成了左右双旋

右左双旋

图1 中红色数字就是每个节点平衡因子，值为65的节点是新插入的节点，当其插入之后，所有节点的平衡因子更新，出现了parent平衡因子为2，cur平衡因子为1，此时需要进行右左调节

图2 观察平衡因子，决定旋转策略为右左双旋，即先进行一次右单旋，再进行一次左单旋。右单旋是以节点80为父节点进行，即节点60的右子树变成节点80的左子树，节点80变成节点60的右子树

图3 右单旋结束，接下来再一次进行以节点40为父节点的左单旋，即节点60的左子树变成节点40的右子树，节点40变成节点60的左子树

源码

AVLTree.h

#pragma once

#include <iostream>
#include <cassert>

template<class K, class V>
struct AVLTreeNode
{
	std::pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;	// balance factor

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

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool insert(const std::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;
		}

		// 更新平衡因子
		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)
				{
					// 左单旋
					rotate_left(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == -1)
				{
					// 右单旋
					rotate_right(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					// 左右双旋
					rotate_left_right(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					// 右左双旋
					rotate_right_left(parent);
				}
				else
				{
					assert(false);
				}

				break;
			}
			else
			{
				assert(false);
			}
		}

		return true;
	}

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

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

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

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

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

		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}

		Node* ppNode = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		if (ppNode == nullptr)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}

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

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

		rotate_left(parent->_left);
		rotate_right(parent);

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

	void rotate_right_left(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		rotate_right(parent->_right);
		rotate_left(parent);

		if (bf == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
			subRL->_bf = 0;
		}
		else if (bf == 0)
		{
			subR->_bf = 0;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void in_order()
	{
		_in_order(_root);
		std::cout << std::endl;
	}

	bool is_balance()
	{
		return _is_balance(_root);
	}

private:
	void _in_order(Node* root)
	{
		if (root != nullptr)
		{
			_in_order(root->_left);
			std::cout << root->_kv.first << ": " << root->_kv.second << std::endl;
			_in_order(root->_right);
		}
	}

	int _height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}

		int lh = _height(root->_left);
		int rh = _height(root->_right);

		return lh > rh ? lh + 1 : rh + 1;
	}

	bool _is_balance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}

		int leftHeight = _height(root->_left);
		int rightHeight = _height(root->_right);

		if (rightHeight - leftHeight != root->_bf)
		{
			std::cout << "平衡因子异常" << root->_kv.first << std::endl;
			return false;
		}

		return std::abs(rightHeight - leftHeight) < 2
			&& _is_balance(root->_left)
			&& _is_balance(root->_right);
	}

private:
	Node* _root = nullptr;
};

test.cpp

#include "AVLTree.h"

void avl_test1()
{
	int a[] = { 2, 4, 5, 8, 10, 1, 3, 5, 7, 9, 100, 200, -100, 0 };
	AVLTree<int, int> t;
	for (auto e : a)
	{
		t.insert(std::make_pair(e, e));
	}
	t.in_order();

	std::cout << t.is_balance() << std::endl << std::endl;
}

void avl_test2()
{
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15};
	AVLTree<int, int> t;
	for (auto e : a)
	{
		t.insert(std::make_pair(e, e));
	}
	t.in_order();

	std::cout << t.is_balance() << std::endl << std::endl;
}

void avl_test3()
{
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	AVLTree<int, int> t;
	for (auto e : a)
	{
		t.insert(std::make_pair(e, e));
	}
	t.in_order();

	std::cout << t.is_balance() << std::endl << std::endl;
}

int main()
{
	avl_test1();
	avl_test2();
	avl_test3();

	return 0;
}