目录
引言
在计算机科学中，AVL 树是一种自平衡的二叉搜索树。它由 Adelson-Velsky 和 Landis 在 1962 年提出，以他们的名字首字母命名。AVL 树通过维持每个节点的平衡因子（即左右子树的高度差）在 [-1, 0, 1] 的范围内，来确保树的高度始终保持在对数级别。这使得 AVL 树非常适合那些需要频繁执行查找、插入和删除操作的应用场景。
本文将详细介绍 AVL 树的原理、实现细节以及一些实际的应用案例。
AVL 树简介
AVL 树是一种特殊的二叉搜索树，其中每个节点的两个子树的高度差至多为 1。这意味着 AVL 树在最坏的情况下也能保持良好的性能，其查找、插入和删除操作的时间复杂度均为 O(log N)。
AVL 树的性质
AVL 树具有以下性质：
- 平衡因子: 每个节点都有一个平衡因子，表示左右子树的高度差。
- 高度: AVL 树的高度始终保持在对数级别，这保证了高效的查找、插入和删除操作。
- 平衡性: 每个节点的两个子树的高度差至多为 1。
AVL 树的旋转
为了保持 AVL 树的平衡性，当插入或删除操作可能导致树失去平衡时，需要通过旋转操作来调整树的结构。AVL 树的旋转主要包括四种类型：
右单旋 (RR)
当一个节点的左子树的高度大于右子树的高度，并且左子树的左子树的高度又大于或等于其右子树的高度时，需要进行右单旋。
左单旋 (LL)
当一个节点的右子树的高度大于左子树的高度，并且右子树的右子树的高度又大于或等于其左子树的高度时，需要进行左单旋。
右左双旋 (RL)
当一个节点的左子树的高度大于右子树的高度，并且左子树的右子树的高度大于其左子树的高度时，需要先对该节点的左子树进行左单旋，然后对该节点进行右单旋。
左右双旋 (LR)
当一个节点的右子树的高度大于左子树的高度，并且右子树的左子树的高度大于其右子树的高度时，需要先对该节点的右子树进行右单旋，然后对该节点进行左单旋。
AVL 树的实现
接下来，我们将使用 C++ 来实现一个简单的 AVL 树。
AVL 树节点
首先定义 AVL 树的节点结构。
template<class T>
struct AVLTreeNode
{
AVLTreeNode(const T& data = T())
: _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 树类，包含插入、删除、旋转等方法。
插入
template<class T>
bool AVLTree<T>::Insert(const T& data)
{
// 省略插入逻辑...
}删除
template<class T>
bool AVLTree<T>::Remove(const T& data)
{
// 省略删除逻辑...
}旋转
实现四种旋转操作。
template<class T>
void AVLTree<T>::RotateR(AVLTreeNode<T>* pParent)
{
// 省略右单旋逻辑...
}
template<class T>
void AVLTree<T>::RotateL(AVLTreeNode<T>* pParent)
{
// 省略左单旋逻辑...
}
template<class T>
void AVLTree<T>::RotateRL(AVLTreeNode<T>* pParent)
{
// 省略右左双旋逻辑...
}
template<class T>
void AVLTree<T>::RotateLR(AVLTreeNode<T>* pParent)
{
// 省略左右双旋逻辑...
}验证
验证 AVL 树的平衡性。
template<class T>
bool AVLTree<T>::IsAVLTree()
{
return _IsAVLTree(_pRoot);
}
template<class T>
bool AVLTree<T>::_IsAVLTree(AVLTreeNode<T>* pRoot)
{
// 省略验证逻辑...
}代码示例
下面是完整的 AVL 树实现示例。
#include <cassert>
#include <iostream>
// 定义 AVL 树的节点结构
template<class T>
struct AVLTreeNode
{
AVLTreeNode(const T& data = T())
: _pLeft(nullptr)
, _pRight(nullptr)
, _pParent(nullptr)
, _data(data)
, _bf(0)
{}
// 指向左子节点的指针
AVLTreeNode<T>* _pLeft;
// 指向右子节点的指针
AVLTreeNode<T>* _pRight;
// 指向父节点的指针
AVLTreeNode<T>* _pParent;
// 存储的数据
T _data;
// 节点的平衡因子，表示左右子树的高度差
int _bf;
};
// 定义 AVL 树类
template<class T>
class AVLTree
{
typedef AVLTreeNode<T> Node;
public:
AVLTree()
: _pRoot(nullptr)
{}
// 在 AVL 树中插入值为 data 的节点
bool Insert(const T& data);
// 从 AVL 树中删除值为 data 的节点
bool Remove(const T& data);
// 验证 AVL 树是否平衡
bool IsAVLTree()
{
return _IsAVLTree(_pRoot);
}
private:
// 验证给定节点是否构成有效的 AVL 树
bool _IsAVLTree(Node* pRoot);
// 计算节点的高度
size_t _Height(Node* pRoot);
// 右单旋
void RotateR(Node* pParent);
// 左单旋
void RotateL(Node* pParent);
// 右左双旋
void RotateRL(Node* pParent);
// 左右双旋
void RotateLR(Node* pParent);
private:
// AVL 树的根节点
Node* _pRoot;
};
// 实现插入操作
template<class T>
bool AVLTree<T>::Insert(const T& data)
{
// 如果树为空，创建一个新的根节点
if (_pRoot == nullptr)
{
_pRoot = new Node(data);
return true;
}
// 寻找插入位置
Node* parent = nullptr;
Node* current = _pRoot;
while (current != nullptr)
{
parent = current;
if (data < current->_data)
{
current = current->_pLeft;
}
else
{
current = current->_pRight;
}
}
// 创建新节点
Node* newNode = new Node(data);
newNode->_pParent = parent;
// 根据数据大小决定插入到左子树还是右子树
if (data < parent->_data)
{
parent->_pLeft = newNode;
}
else
{
parent->_pRight = newNode;
}
// 更新平衡因子
while (parent != nullptr)
{
// 计算左右子树的高度
size_t leftHeight = _Height(parent->_pLeft);
size_t rightHeight = _Height(parent->_pRight);
// 设置平衡因子
parent->_bf = static_cast<int>(rightHeight - leftHeight);
// 如果不平衡，则进行旋转
if (parent->_bf > 1 || parent->_bf < -1)
{
// 判断需要哪种类型的旋转
if (parent->_pLeft != nullptr && parent->_pLeft->_bf == 1)
{
RotateL(parent->_pParent); // 左单旋
}
else if (parent->_pRight != nullptr && parent->_pRight->_bf == -1)
{
RotateR(parent->_pParent); // 右单旋
}
else if (parent->_pLeft != nullptr && parent->_pLeft->_bf == -1)
{
RotateLR(parent->_pParent); // 左右双旋
}
else if (parent->_pRight != nullptr && parent->_pRight->_bf == 1)
{
RotateRL(parent->_pParent); // 右左双旋
}
break;
}
// 继续向上更新平衡因子
parent = parent->_pParent;
}
return true;
}
// 实现删除操作
template<class T>
bool AVLTree<T>::Remove(const T& data)
{
// 删除逻辑省略...
// ...
// ...
}
// 实现右单旋
template<class T>
void AVLTree<T>::RotateR(Node* pParent)
{
assert(pParent->_pLeft != nullptr); // 确保父节点有左子节点
// 获取父节点的左子节点
Node* pChild = pParent->_pLeft;
// 将父节点的左子节点设置为左子节点的右子节点
pParent->_pLeft = pChild->_pRight;
// 如果父节点的左子节点不为空，更新其父节点
if (pParent->_pLeft != nullptr)
{
pParent->_pLeft->_pParent = pParent;
}
// 将左子节点的右子节点设置为父节点
pChild->_pRight = pParent;
// 更新父节点的父节点
pParent->_pParent = pChild;
// 更新父节点的父节点指向
if (pParent == _pRoot)
{
_pRoot = pChild;
}
else if (pParent->_pParent->_pLeft == pParent)
{
pParent->_pParent->_pLeft = pChild;
}
else
{
pParent->_pParent->_pRight = pChild;
}
// 更新左子节点的父节点指向
pChild->_pParent = pParent->_pParent;
}
// 实现左单旋
template<class T>
void AVLTree<T>::RotateL(Node* pParent)
{
assert(pParent->_pRight != nullptr); // 确保父节点有右子节点
// 获取父节点的右子节点
Node* pChild = pParent->_pRight;
// 将父节点的右子节点设置为右子节点的左子节点
pParent->_pRight = pChild->_pLeft;
// 如果父节点的右子节点不为空，更新其父节点
if (pParent->_pRight != nullptr)
{
pParent->_pRight->_pParent = pParent;
}
// 将右子节点的左子节点设置为父节点
pChild->_pLeft = pParent;
// 更新父节点的父节点
pParent->_pParent = pChild;
// 更新父节点的父节点指向
if (pParent == _pRoot)
{
_pRoot = pChild;
}
else if (pParent->_pParent->_pLeft == pParent)
{
pParent->_pParent->_pLeft = pChild;
}
else
{
pParent->_pParent->_pRight = pChild;
}
// 更新右子节点的父节点指向
pChild->_pParent = pParent->_pParent;
}
// 实现右左双旋
template<class T>
void AVLTree<T>::RotateRL(Node* pParent)
{
RotateR(pParent->_pLeft); // 先对父节点的左子节点进行右单旋
RotateL(pParent); // 再对父节点进行左单旋
}
// 实现左右双旋
template<class T>
void AVLTree<T>::RotateLR(Node* pParent)
{
RotateL(pParent->_pRight); // 先对父节点的右子节点进行左单旋
RotateR(pParent); // 再对父节点进行右单旋
}
// 验证给定节点是否构成有效的 AVL 树
template<class T>
bool AVLTree<T>::_IsAVLTree(Node* pRoot)
{
// 如果树为空，则它是平衡的
if (pRoot == nullptr)
{
return true;
}
// 验证左右子树是否为 AVL 树
if (!_IsAVLTree(pRoot->_pLeft) || !_IsAVLTree(pRoot->_pRight))
{
return false;
}
// 计算左右子树的高度
size_t leftHeight = _Height(pRoot->_pLeft);
size_t rightHeight = _Height(pRoot->_pRight);
// 检查当前节点的平衡因子是否有效
if (abs(static_cast<int>(rightHeight - leftHeight)) > 1)
{
return false;
}
return true;
}
// 计算节点的高度
template<class T>
size_t AVLTree<T>::_Height(Node* pRoot)
{
// 如果节点为空，则高度为 0
if (pRoot == nullptr)
{
return 0;
}
// 递归计算左右子树的高度
size_t leftHeight = _Height(pRoot->_pLeft);
size_t rightHeight = _Height(pRoot->_pRight);
// 返回较大的高度值加 1
return 1 + std::max(leftHeight, rightHeight);
}
// 主函数
int main()
{
AVLTree<int> avlTree;
avlTree.Insert(10);
avlTree.Insert(20);
avlTree.Insert(30);
avlTree.Insert(40);
avlTree.Insert(50);
avlTree.Insert(25);
std::cout << "AVL Tree is balanced: " << avlTree.IsAVLTree() << std::endl;
return 0;
}性能考量
AVL 树的主要优势在于其高度始终保持在对数级别，这保证了高效的查找、插入和删除操作。然而，AVL 树在进行旋转操作时可能会带来一定的开销。对于频繁插入和删除操作的应用场景，AVL 树可能不是最佳选择，因为每次插入或删除操作后都需要进行旋转来维持平衡。
总结
本文介绍了 AVL 树的基本概念、性质、旋转操作以及在 C++ 中的实现。AVL 树是一种自平衡的二叉搜索树，适用于需要高效查找、插入和删除操作的应用场景。通过本文的学习，读者应该能够理解 AVL 树的工作原理，并能够在实际项目中运用它。
646
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
