目录
3. 新节点插入较高左子树的右侧---左右:先左单旋再右单旋
4. 新节点插入较高右子树的左侧---右左:先右单旋再左单旋
后记:●由于作者水平有限,文章难免存在谬误之处,敬请读者斧正,俚语成篇,恳望指教!
1.AVL树
1.1AVL树的概念
二叉搜索树虽可以缩短查找的效率,但如果数据有序或接近有序二叉搜索树将退化为单支树,查找元素相当于在顺序表中搜索元素,效率低下。因此,两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法:当向二叉搜索树中插入新结点后,如果能保证每个结点的左右子树高度之差的 绝对值 不超过1(需要对树中的结点进行调整),即可降低树的高度,从而减少平均 搜索长度。一棵AVL树或者是空树,或者是具有以下性质的二叉搜索树:它的左右子树都是AVL树左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
如果一棵二叉搜索树是高度平衡的,它就是AVL树。如果它有n个结点,其高度可保持在O(log_2 n),搜索时间复杂度O(log_2 n)。
1.2 AVL树节点的定义
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; // 该节点的平衡因子 };
1.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; }
1.4 AVL树的旋转
如果在一棵原本是平衡的AVL树中插入一个新节点,可能造成不平衡,此时必须调整树的结构,使之平衡化。根据节点插入位置的不同,AVL树的旋转分为四种:1. 新节点插入较高左子树的左侧---左左:右单旋
/* 上图在插入前,AVL树是平衡的,新节点插入到30的左子树(注意:此处不是左孩子)中,30左子树增加了一层, 导致以60为根的二叉树不平衡,要让60平衡,只能将60左子树的高度减少一层,右子树增加一层, 即将左子树往上提, 这样60转下来,因为60比30大,只能将其放在30的右子树,而如果30有 右子树,右子树根的值一定大于30,小于60, 只能将其放在60的左子树,旋转完成后,更新节点 的平衡因子即可。在旋转过程中, 有以下几种情况需要考虑: 1. 30节点的右孩子可能存在,也可能不存在 2. 60可能是根节点,也可能是子树 如果是根节点,旋转完成后,要更新根节点 如果是子树, 可能是某个节点的左子树,也可能是右子树 同学们再此处可举一些详细的例子进行画图,考虑各种情况,加深旋转的理解 */ void _RotateR(PNode pParent) { // pSubL: pParent的左孩子 // pSubLR: pParent左孩子的右孩子,注意:该 PNode pSubL = pParent->_pLeft; PNode pSubLR = pSubL->_pRight; // 旋转完成之后,30的右孩子作为双亲的左孩子 pParent->_pLeft = pSubLR; // 如果30的左孩子的右孩子存在,更新亲双亲 if(pSubLR) pSubLR->_pParent = pParent; // 60 作为 30的右孩子 pSubL->_pRight = pParent; // 因为60可能是棵子树,因此在更新其双亲前必须先保存60的双亲 PNode pPParent = pParent->_pParent; // 更新60的双亲 pParent->_pParent = pSubL; // 更新30的双亲 pSubL->_pParent = pPParent; // 如果60是根节点,根新指向根节点的指针 if (NULL == pPParent) { _pRoot = pSubL; pSubL->_pParent = NULL; } else { // 如果60是子树,可能是其双亲的左子树,也可能是右子树 if (pPParent->_pLeft == pParent) pPParent->_pLeft = pSubL; else pPParent->_pRight = pSubL; } // 根据调整后的结构更新部分节点的平衡因子 pParent->_bf = pSubL->_bf = 0; }
2. 新节点插入较高右子树的右侧---右右:左单旋
实现及情况考虑可参考右单旋。3. 新节点插入较高左子树的右侧---左右:先左单旋再右单旋
将双旋变成单旋后再旋转,即:先对30进行左单旋,然后再对90进行右单旋,旋转完成后再考虑平衡因子的更新。// 旋转之前,60的平衡因子可能是-1/0/1,旋转完成之后,根据情况对其他节点的平衡因子进行调整 void _RotateLR(PNode pParent) { PNode pSubL = pParent->_pLeft; PNode pSubLR = pSubL->_pRight; // 旋转之前,保存pSubLR的平衡因子,旋转完成之后,需要根据该平衡因子来调整其他节 点的平衡因子 int bf = pSubLR->_bf; // 先对30进行左单旋 _RotateL(pParent->_pLeft); // 再对90进行右单旋 _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为根的子树个高度降低,已经平衡,不需要再向上更新。
1.5 AVL树的验证
AVL树是在二叉搜索树的基础上加入了平衡性的限制,因此要验证AVL树,可以分两步:1. 验证其为二叉搜索树如果中序遍历可得到一个有序的序列,就说明为二叉搜索树2. 验证其为平衡树
- 每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
- 节点的平衡因子是否计算正确
int _Height(PNode pRoot); bool _IsBalanceTree(PNode pRoot) { // 空树也是AVL树 if (nullptr == pRoot) return true; // 计算pRoot节点的平衡因子:即pRoot左右子树的高度差 int leftHeight = _Height(pRoot->_pLeft); int rightHeight = _Height(pRoot->_pRight); int diff = rightHeight - leftHeight; // 如果计算出的平衡因子与pRoot的平衡因子不相等,或者 // pRoot平衡因子的绝对值超过1,则一定不是AVL树 if (diff != pRoot->_bf || (diff > 1 || diff < -1)) return false; // pRoot的左和右如果都是AVL树,则该树一定是AVL树 return _IsBalanceTree(pRoot->_pLeft) && _IsBalanceTree(pRoot - > _pRight); }
3. 验证用例结合上述代码按照以下的数据次序,自己动手画AVL树的创建过程,验证代码是否有漏洞。
- 常规场景1
{16, 3, 7, 11, 9, 26, 18, 14, 15}
- 特殊场景2
{4, 2, 6, 1, 3, 5, 15, 7, 16, 14}![]()
1.6 AVL树的删除(了解)
因为AVL树也是二叉搜索树,可按照二叉搜索树的方式将节点删除,然后再更新平衡因子,只不 错与删除不同的时,删除节点后的平衡因子更新,最差情况下一直要调整到根节点的位置。具体实现可参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。
1.7 AVL树的性能
AVL树是一棵绝对平衡的二叉搜索树,其要求每个节点的左右子树高度差的绝对值都不超过1,这 样可以保证查询时高效的时间复杂度,即$log_2 (N)$。但是如果要对AVL树做一些结构修改的操 作,性能非常低下,比如:插入时要维护其绝对平衡,旋转的次数比较多,更差的是在删除时, 有可能一直要让旋转持续到根的位置。因此:如果需要一种查询高效且有序的数据结构,而且数 据的个数为静态的(即不会改变),可以考虑AVL树,但一个结构经常修改,就不太适合。
2.AVL树的实现:
通过功能函数的模块化,然后进行封装,实现AVL的数据插入、遍历、树的高度求解、树的平衡判断。在插入数据的过程中,会涉及到树的结构的调整,这就需要借助平衡因子使得调整更加方便。
2.1功能函数:
(1)定义AVL树的基本结构:
(2)Insert函数以及平衡因子bf的调整:
(3)左单旋RotateL:
(4)右单旋RotateR:
![]()
(5)左右双旋RotateLR:
![]()
(6)右左双旋RotateRL:
(7)遍历(递归版):
(8)求树的高度:
(9)判断是否为平衡二叉树:
(10)测试用例:
![]()
2.2完整源码:
(1)AVLTree.h:
#pragma once #include<iostream> #include<vector> #include<queue> #include<time.h> #include<set> #include<map> #include<string> #include<cassert> using namespace std; template<class K,class V> struct AVLTreeNode { pair<K, V> _kv; //key<=>(pair*)->first value<=>(pair*)->second AVLTreeNode<K, V>* _left; AVLTreeNode<K, V>* _right; AVLTreeNode<K, V>* _parent; int _bf; //balance factor 这里定义成右子树-左子树 //AVL并无强制规定设计平衡因子,这里选择使用,方便控制平衡 AVLTreeNode(const 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: //Find //Erase //插入数据 bool Insert(const pair<K, V>& kv) { //1.先按照搜索树的规则插入数据 //2.判断是否遵循平衡规则,若违反,就旋转进行调整 if (_root == nullptr) { _root = new Node(kv); _root->_bf = 0; 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; } else { parent->_left = cur; } cur->_parent = parent; //更新平衡因子: //插入新结点后: //1.树的高度层次增加,要一直更新到根结点(_root)的bf //2.树的高度不变,只更新当前的parent的bf,就更新完成 //3.更新完成后,若违反规则,处理旋转 //注:更新bf,parent和cur也会更新 //插入结点后,平衡因子的判断、更新 while (parent) { //当前新插入这个结点的parent一定会更新,后面的需要进行判断 if (cur == parent->_right) { parent->_bf++; } else { parent->_bf--; } // 是否继续更新? if (parent->_bf == 0) //原来的bf:1 or -1 -> 0 插入节点填上矮的那边 { // 高度不变,更新结束 break; } else if (parent->_bf == 1 || parent->_bf == -1) { // 原来的bf:0 -> 1 或 -1 插入节点导致一边变高了 // 子树的高度变了,继续更新,这里更新后,parent也变了,后续是否更新要进行判断 cur = cur->_parent; parent = parent->_parent; } else if (parent->_bf == 2 || parent->_bf == -2) { // -1 or 1 -> 2 或 -2 插入节点导致本来高一边又变高了 // 子树不平衡 -- 需要旋转处理 if (parent->_bf == 2 && cur->_bf == 1) // 左单旋 { RotateL(parent); } else if (parent->_bf == -2 && cur->_bf == -1) // 右单旋 { RotateR(parent); } else if (parent->_bf == -2 && cur->_bf == 1) // 左右双旋 { RotateLR(parent); } else if (parent->_bf == 2 && cur->_bf == -1) // 右左双旋 { RotateRL(parent); } break; } else { // 插入之前AVL就存在不平衡子树,|平衡因子| >= 2的节点 assert(false); } } return true; } private: //1.右边高,向左单旋转 void RotateL(Node* parent) { Node* subR = parent->_right; Node* subRL = subR->_left; parent->_right = subRL; if (subRL) subRL->_parent = parent; Node* ppNode = parent->_parent; subR->_left = parent; parent->_parent = subR; if (parent == _root) { _root = subR; _root->_parent = nullptr; } else { if (parent == ppNode->_left) { ppNode->_left = subR; } else { ppNode->_right = subR; } subR->_parent = ppNode; } // 更新平衡因子 parent->_bf = 0; subR->_bf = 0; } //2.左边高,向右单旋转 void RotateR(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 (parent == _root) { _root = subL; _root->_parent = nullptr; } else { if (ppNode->_left == parent) { ppNode->_left = subL; } else { ppNode->_right = subL; } subL->_parent = ppNode; } subL->_bf = parent->_bf = 0; } //3.左右双旋 void RotateLR(Node* parent) { Node* subL = parent->_left; Node* subLR = subL->_right; int bf = subLR->_bf; RotateL(parent->_left); RotateR(parent); // 更新平衡因子 if (bf == 0) { parent->_bf = 0; subL->_bf = 0; subLR->_bf = 0; } else 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 { // subLR->_bf旋转前就有问题 assert(false); } } //4.右左双旋 void RotateRL(Node* parent) { Node* subR = parent->_right; Node* subRL = subR->_left; int bf = subRL->_bf; RotateR(parent->_right); RotateL(parent); if (bf == 0) { subRL->_bf = 0; parent->_bf = 0; subR->_bf = 0; } else if (bf == 1) { subRL->_bf = 0; parent->_bf = -1; subR->_bf = 0; } else if (bf == -1) { subRL->_bf = 0; parent->_bf = 0; subR->_bf = 1; } else { // subLR->_bf旋转前就有问题 assert(false); } } //中序遍历(递归版) void _InOrder(Node* root) { if (root == nullptr) return; _InOrder(root->_left); cout << root->_kv.first << " "; _InOrder(root->_right); } //前序遍历(递归版) void _PrevOrder(Node* root) { if (root == nullptr) return; cout << root->_kv.first << " "; _PrevOrder(root->_left); _PrevOrder(root->_right); } //后序遍历(递归版) void _PostOrder(Node* root) { if (root == nullptr) return; _PostOrder(root->_left); _PostOrder(root->_right); cout << root->_kv.first << " "; } //求树的高度 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 _IsBalanceTree(Node* root) { // 空树也是AVL树 if (nullptr == root) return true; // 计算pRoot节点的平衡因子:即pRoot左右子树的高度差 int leftHeight = _Height(root->_left); int rightHeight = _Height(root->_right); int diff = rightHeight - leftHeight; // 如果计算出的平衡因子与pRoot的平衡因子不相等,或者 // pRoot平衡因子的绝对值超过1,则一定不是AVL树 if (abs(diff) >= 2) { cout << root->_kv.first << "节点平衡因子异常!" << endl; return false; } if (diff != root->_bf) { cout << root->_kv.first << "节点平衡因子不符合实际!" << endl; return false; } // pRoot的左和右如果都是AVL树,则该树一定是AVL树 return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right); } public: //1.中序遍历(递归版) void InOrder() { _InOrder(_root); cout << endl; } //2.前序遍历(递归版) void PrevOrder() { _PrevOrder(_root); cout << endl; } //3.后序序遍历(递归版) void PostOrder() { _PostOrder(_root); cout << endl; } //4.层序遍历 vector<vector<int>> levelOrder() { vector<vector<int>> vv; if (_root == nullptr) return vv; queue<Node*> q; int levelSize = 1; q.push(_root); while (!q.empty()) { // levelSize控制一层一层出 vector<int> levelV; while (levelSize--) { Node* front = q.front(); q.pop(); levelV.push_back(front->_kv.first); if (front->_left) q.push(front->_left); if (front->_right) q.push(front->_right); } vv.push_back(levelV); for (auto e : levelV) { cout << e << " "; } cout << endl; // 上一层出完,下一层就都进队列 levelSize = q.size(); } return vv; } bool IsBalanceTree() { return _IsBalanceTree(_root); } int Height() { return _Height(_root); } private: Node* _root = nullptr; };
(2)test.cpp:
#include"AVLTree.h" void TestAVLTree1() { AVLTree<int, int> t; t.Insert(make_pair(1, 1)); t.Insert(make_pair(2, 2)); t.Insert(make_pair(4, 3)); t.Insert(make_pair(4, 4)); } void TestAVLTree2() { int a[] = { 5,3,7,1,4,6,8,0,2,9 }; AVLTree<int, int> t; for (auto e : a) { t.Insert(make_pair(e, e)); } cout << endl; t.levelOrder(); t.Insert(make_pair(10,10)); t.Insert(make_pair(11,11)); t.levelOrder(); } void TestAVLTree3() { //使用随机值测试 const size_t N = 100; vector<int> v; v.reserve(N); srand(time(0)); for (size_t i = 0; i < N; ++i) { v.push_back(rand()); } AVLTree<int, int> t; for (auto e : v) { t.Insert(make_pair(e, e)); } t.levelOrder(); cout << endl; } void TestAVLTree4() { //使用有序测试 const size_t N = 20; //测试N个数据 vector<int> v; v.reserve(N); srand(time(0)); for (size_t i = 0; i < N; ++i) { //v.push_back(rand()); v.push_back(i); } AVLTree<int, int> t; for (auto e : v) { t.Insert(make_pair(e, e)); } //t.levelOrder(); //t.InOrder(); //t.PrevOrder(); //t.PostOrder(); cout << "是否平衡?(返回值1代表是,返回值0代表不是):" << t.IsBalanceTree() << endl; cout << "高度:" << t.Height() << endl; cout << endl; } void TestAVLTree5() { int a[] = { 5,3,7,1,4,6,8,0,2,9 }; //int a[] = {0,1,2,3,4,5,6,7,8,9 }; //int a[] = { 1,1,1,1,1,1,1,1,1 }; AVLTree<int, int> t; for (auto e : a) { t.Insert(make_pair(e, e)); } t.levelOrder(); cout << "是否为平衡树?(1:是 0:不是):" << t.IsBalanceTree() << endl; cout << "树的高度:" << t.Height() << endl; cout << endl; t.Insert(make_pair(10, 10)); t.Insert(make_pair(11, 11)); t.levelOrder(); cout << endl; //t.InOrder(); //t.PrevOrder(); //t.PostOrder(); cout << "是否为平衡树?(1:是 0:不是):" << t.IsBalanceTree() << endl; cout << "树的高度:" << t.Height() << endl; cout << endl; } int main() { //TestAVLTree1(); //TestAVLTree2(); TestAVLTree3(); //TestAVLTree4(); //TestAVLTree5(); return 0; }
2.3总结:
通过上述过程,实现了对Insert过程中对二叉树调整、判断等。而AVL树还有Find、Erase等操作,由于难度较大,具体实现可参考教材或其他资料。
这里的AVL借助了平衡因子使得二叉树结构的判断以及调整更加方便,遇到难以理解的过程要画图分析或编译器调试。