目录
一、AVL树的概念
理想状态下，当数据乱序并且二叉搜索树的形态趋近于满二叉树的时候，二叉搜索树查找的时间复杂度为O(logN)效率很高，二叉搜索树虽然可以提高查找的效率，但是当数据有序或接近有序的时候，二叉搜索树会退化成单支树，这时候进行数据查找的时间复杂度O(N)，相当于在顺序表中遍历数据进行查找，效率十分低。
- 基于上述情况，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年提出AVL树（这里可以看出AVL树是以人名命名的），即使用AVL树（平衡搜索树）解决上述问题
- AVL树是基于二叉搜索树实现的，即当向二叉搜素树中插入节点后，如果能保证二叉搜索树的左右子树的高度差的绝对值不超过1（通过对树中的节点进行旋转实现），即高度差取值 -1，0，1，那么就可以降低树的高度
- 从而使树的形态退而求其次的达到一种趋近于满二叉树的形态，达到一种平衡，从而减少平均搜索长度，这样被优化的二叉搜索树进行查找的时间复杂度也就会降为O(logN)，我们把这种被优化的二叉搜索树叫做AVL树
一颗AVL树要么是空树，要么是具有以下性质的二叉搜索树
- 它的左右子树都是AVL树
- 左右子树的高度差（平衡因子）的绝对值不超过1，即高度差取值-1，0，1
- AVL树的节点如果有N个，那么树的高度是logN，那么搜索的时间复杂度为O(logN)
平衡因子等于右子树的高度减去左子树的高度
二、AVL树的模拟实现
定义AVL树节点
这个AVL树节点的结构包含5个成员，各自的作用如下：
- pair<K, V> _kv
- 作用：存储当前节点的键值对数据，是节点的核心数据载体。
- 示例：若 K 为 int 、V 为 string ，则 _kv 可存储 {10, "apple"} 这样的键值对。
- AVLTreeNode<K, V>* _left
- 作用：指向当前节点的左子节点，用于维护二叉搜索树的左子树结构。
- AVLTreeNode<K, V>* _right
- 作用：指向当前节点的右子节点，用于维护二叉搜索树的右子树结构。
- AVLTreeNode<K, V>* _parent
- 作用：指向当前节点的父节点，是AVL树的关键成员：
- 插入新节点后，需向上回溯更新平衡因子， _parent 用于逐层找到父节点；
- 旋转调整树结构时，需通过 _parent 维护父子节点的关系。
- int _bf （balance factor）
- 作用：存储当前节点的平衡因子（定义为"右子树高度 - 左子树高度"），用于判断树是否失衡：
- 正常范围是 -1、0、1 ；
- 若 _bf == ±2 ，说明当前子树失衡，需要通过旋转调整。
AVLTree类模板/AVL树的框架
节点的插入
插入的逻辑:
- 第一步要先像普通二叉搜索树一样找到插入位置，创建新节点并挂到对应父节点下；
- 第二步接着从父节点开始向上更新平衡因子，根据平衡因子的变化决定是否继续更新；
- 第三步若出现平衡因子为±2的失衡情况，就要按失衡类型做对应旋转调整，以此维持树的平衡性。
那我们一步一步来进行讲解:
第一步:
这段代码的第一部分，是先判断树是不是空的------要是根节点是空的，就直接把新节点当成根，插入完成；要是树已经有根了，就准备开始找插入的位置。
接下来定义两个指针：一个叫parent，一开始是空的；另一个叫cur，从根节点开始。然后进入循环，只要cur不是空的，就一直找：如果当前cur的值比要插入的值小，就把cur记成parent，再让cur跳到自己的右子节点；要是cur的值比插入的值大，就把cur记成parent，让cur跳到自己的左子节点；要是值一样，说明重复了，直接插入失败。
等循环结束，cur就变成空的了(构造函数里面用空来初始化)，这时候parent就是新节点该挂的父节点。接着创建新节点，把它的平衡因子设为0，再看parent的键和新节点的键谁大：要是parent的键小，就把新节点挂到parent的右边；要是parent的键大，就挂到左边------这样新节点就成功接到树里了。
第二步:
这部分是插入节点后更新平衡因子的逻辑，首先，先把新节点的父指针指向刚才找到的parent（让新节点和父节点建立双向关联）。
然后进入while循环，循环的起点是parent（也就是新节点的父节点）：第一步先判断新节点是parent的左孩子还是右孩子------如果是右孩子，就给parent的平衡因子加1；如果是左孩子，就减1。
接下来看parent的平衡因子变成了多少：如果平衡因子变成0，说明这棵子树的高度没变化，不会影响上面的节点，直接结束循环；
如果平衡因子变成1或者-1，说明这棵子树的高度变了，得继续往上更新------这时候把cur换成当前的parent，parent换成parent的父节点，继续循环处理上一层；
如果平衡因子变成2或者-2，说明这棵子树失衡了，得用旋转来调整结构，调整完就结束循环。
整个过程就是从新节点的父节点开始，一层一层往上更新平衡因子，同时判断子树是否失衡，直到平衡因子回到0或者出现失衡需要旋转为止。
平衡因子更新原则
- 平衡因子=右子树高度-左子树高度
- 只有子树高度变化才会影响当前结点平衡因子。
- 插入结点，会增加高度，所以新增结点在parent的右子树，parent的平衡因子++，新增结点在parent的左子树，parent平衡因子--
- parent所在子树的高度是否变化决定了是否会继续往上更新
更新停止条件
- 更新后parent的平衡因子等于0，更新中parent的平衡因子变化为-1->0或者1->0，说明更新前parent子树一边高一边低，新增的结点插入在低的那边，插入后parent所在的子树高度不变，不会影响parent的父亲结点的平衡因子，更新结束。
- 更新后parent的平衡因子等于1或-1，更新前更新中parent的平衡因子变化为0->1或者0->-1，说明更新前parent子树两边一样高，新增的插入结点后，parent所在的子树一边高一边低，parent所在的子树符合平衡要求，但是高度增加了1，会影响parent的父亲结点的平衡因子，所以要继续向上更新。
- 更新后parent的平衡因子等于2或-2，更新前更新中parent的平衡因子变化为1->2或者-1->-2，说明更新前parent子树一边高一边低，新增的插入结点在高的那边，parent所在的子树高的那边更高了，破坏了平衡，parent所在的子树不符合平衡要求，需要旋转处理，旋转的目标有两个: 1、把parent子树旋转平衡。2、降低parent子树的高度，恢复到插入结点以前的高度。所以旋转后也不需要继续往上更新，插入结束。
- 不断更新，更新到根，跟的平衡因子是1或-1也停止了。
更新到中间结点，3为根的子树高度不变，不会影响上一层，更新结束
最坏更新到根停止
更新到10结点，平衡因子为2，10所在的子树已经不平衡，需要旋转处理
第三步:旋转
旋转的前提:
插入（或删除）节点后，某个节点的平衡因子变为2或-2（即该节点的左右子树高度差超过了1），导致这棵子树失去平衡。
旋转的原则:
- 保持搜索树的规则
- 让旋转的树从不满足变平衡，其次降低旋转树的高度
旋转总共分为四种，左单旋/右单旋/左右双旋/右左双旋。
右单旋
- 下图1展示的是10为根的树，有a/b/c抽象为三棵高度为h的子树(h>=0)，a/b/c均符合AVL树的要求。10可能是整棵树的根，也可能是一个整棵树中局部的子树的根。这里a/b/c是高度为h的子树，是一种概括抽象表示，代表了所有右单旋的场景，实际右单旋形态有很多种，具体图2/图3/图4/图5进行了详细描述。
- 在a子树中插入一个新结点，导致a子树的高度从h变成h+1，不断向上更新平衡因子，导致10的平衡因子从-1变成-2，10为根的树左右高度差超过1，违反平衡规则。10为根的树左边太高了，需要往右边旋转，控制两棵树的平衡。
- 旋转核心步骤，因为5 < b子树的值 < 10，将b变成10的左子树，10变成5的右子树，5变成这棵树新的根，符合搜索树的规则，控制了平衡，同时这棵的高度恢复到了插入之前的h+2，符合旋转原则。如果插入之前10整棵树的一个局部子树，旋转后不会再影响上一层，插入结束了。
情况一:
情况二:
情况三:
情况四:
首先，先找到失衡的节点的左子节点（叫subL） ，再找到subL的右子节点（叫subLR） 。
然后，把subLR接到父节点的左孩子位置 ------要是subLR不是空的，还得让subLR的父指针指向父节点，这样subLR就不会丢。
接着，记录下父节点的父节点（叫parentParent） ，方便之后把旋转后的子树接回整棵树里。
核心的旋转步骤来了：让subL的右孩子变成原来的父节点 ，同时让父节点的父指针指向subL------这一步相当于把subL变成了原来父节点的新父节点。
之后要判断原来的父节点是不是整棵树的根 ：
要是的话，就把subL改成新的根，同时让subL的父指针变成空；
要是不是的话，就看原来的父节点是parentParent的左孩子还是右孩子，把subL接到对应的位置，再让subL的父指针指向parentParent。
最后，把原来的父节点和subL的平衡因子都设为0，这样旋转后的子树就平衡了。
左旋转
- 下面图6展示的是以10为根的树，有a/b/c抽象为三棵高度为h的子树（h≥0），a/b/c均符合AVL树的要求。10可能是整棵树的根，也可能是整棵树中局部的子树的根。这里a/b/c是高度为h的子树，是一种概括抽象表示，代表了所有右单旋的场景，实际右单旋形态有很多种，具体跟上面左旋类似。
- 在a子树中插入一个新结点，导致a子树的高度从h变成h+1，不断向上更新平衡因子，导致10的平衡因子从1变成2，10为根的树左右高度差超过1，违反平衡规则。10为根的树右边太高了，需要往左边旋转，控制两棵树的平衡。
- 旋转核心步骤：因为10 < b子树的值 < 15，将b变成10的右子树，10变成15的左子树，15变成这棵树新的根，符合搜索树的规则，控制了平衡，同时这棵树的高度恢复到了插入之前的h+2，符合旋转原则。如果插入之前10是整棵树的一个局部子树，旋转后不会再影响上一层，插入结束了。
左单旋首先，先找到失衡的节点的右子节点（叫subR） ，再找到subR的左子节点（叫subRL）。
然后，把subRL接到父节点的右孩子位置 ------要是subRL不是空的，还得让subRL的父指针指向父节点，这样subRL就不会丢。
接着，记录下父节点的父节点（叫parentParent） ，方便之后把旋转后的子树接回整棵树里。
核心的旋转步骤来了：让subR的左孩子变成原来的父节点，同时让父节点的父指针指向subR ------这一步相当于把subR变成了原来父节点的新父节点。
之后要判断原来的父节点是不是整棵树的根：
要是的话，就把subR改成新的根，同时让subR的父指针变成空；
要是不是的话，就看原来的父节点是parentParent的左孩子还是右孩子，把subR接到对应的位置，再让subR的父指针指向parentParent。
最后，把原来的父节点和subR的平衡因子都设为0，这样旋转后的子树就平衡了。
左右双旋
通过下面的图7和图8可以看到，左边高时，如果插入位置不是在a子树，而是插入在b子树，b子树高度从h变成h+1，引发旋转，右单旋无法解决问题，右单旋后，我们的树依旧不平衡。右单旋解决的纯粹的左边高 ，但是插入在b子树中，10为跟的子树不再是单纯的左边高，对于10是左边高，但对于5是右边高，需要用两次旋转才能解决，以5为旋转点进行一个左单旋，以10为旋转点进行一个右单旋，这棵树这棵树就平衡了。
图7和图8分别为左右双旋中h==0和h==1具体场景分析，下面我们将a/b/c子树抽象为高度h的AVL子树进行分析，另外我们需要把b子树的细节进一步展开为8和左子树高度为h-1的e和f子树，因为我们要对b的父亲5为旋转点进行左单旋，左单旋需要动b树中的左子树。b子树中新增结点的位置不同，平衡因子更新的细节也不同，通过观察8的平衡因子不同，这里我们要分三个场景讨论。
- 场景1：h>=1时，新增结点插入在e子树，e子树高度从h-1升为h并不断更新8->5->10平衡因子，引发旋转，其中8的平衡因子为-1，旋转后8和5平衡因子为0，10平衡因子为1。
- 场景2：h>=1时，新增结点插入在f子树，f子树高度从h-1变为h并不断更新8->5->10平衡因子，引发旋转，其中8的平衡因子为1，旋转后8和10平衡因子为0，5平衡因子为-1。
- 场景3：h==0时，a/b/c都是空树，b自己就是一个新增结点，不断更新5->10平衡因子，引发旋转，其中8的平衡因子为0，旋转后8和10和5平衡因子均为0。
左右双旋用来解决"父节点左子树的右子树过高"的失衡问题
首先，找到失衡节点 parent 的左孩子 subL ，再找到 subL 的右孩子 subLR ，同时记录 subLR 的平衡因子 bf 。
然后分两步旋转 ：先对 subL 执行左单旋 ，再对 parent 执行右单旋 ------这两步组合就是"左右双旋"，先调整局部结构，再调整整体结构。
最后根据 subLR 的平衡因子 bf ，修正各节点的平衡因子 ：
若 bf 是0，那 subL 、 parent 、 subLR 的平衡因子都设为0；
若 bf 是1， subL 的平衡因子设为-1， parent 设为0， subLR 设为0；
若 bf 是-1， subL 的平衡因子设为0， parent 设为1， subLR 设为0；
其他情况会触发断言，说明逻辑有异常。
这个函数的作用是修复单旋解决不了的复杂失衡，让AVL树恢复平衡。
右左双旋
跟左右双旋类似，下面我们将a/b/c子树抽象为高度h的AVL子树进行分析，另外我们需要把b子树的细节进一步展开为12和左子树高度为h-1的e和f子树，因为我们要对b的父亲15为旋转点进行右单旋，右单旋需要动b树中的右子树。b子树中新增结点的位置不同，平衡因子更新的细节也不同，通过观察12的平衡因子不同，这里我们要分三个场景讨论。
- 场景1：h>=1时，新增结点插入在e子树，e子树高度从h-1变为h并不断更新12->15->10平衡因子，引发旋转，其中12的平衡因子为-1，旋转后10和12平衡因子为0，15平衡因子为1。
- 场景2：h>=1时，新增结点插入在f子树，f子树高度从h-1变为h并不断更新12->15->10平衡因子，引发旋转，其中12的平衡因子为1，旋转后15和12平衡因子为0，10平衡因子为-1。
- 场景3：h==0时，a/b/c都是空树，b自己就是一个新增结点，不断更新15->10平衡因子，引发旋转，其中12的平衡因子为0，旋转后10和12和15平衡因子均为0。
右左双旋函数用来解决"父节点右子树的左子树过高"的失衡问题
首先，找到失衡节点 parent 的右孩子 subR ，再找到 subR 的左孩子 subRL ，同时记录 subRL 的平衡因子 bf 。
然后分两步旋转：先对 subR 执行右单旋，再对 parent 执行左单旋 ------这两步组合就是"右左双旋"，先调整局部结构，再修正整体的平衡。
最后根据 subRL 的平衡因子 bf ，调整各节点的平衡因子 ：
若 bf 是0， subR 、 subRL 、 parent 的平衡因子都设为0；
若 bf 是1， subR 和 subRL 设为0， parent 设为-1；
若 bf 是-1， subR 设为1， subRL 和 parent 设为0；
其他情况会触发断言，说明逻辑有异常。
这个函数是用来修复单旋解决不了的复杂失衡，让AVL树恢复平衡的关键函数之一。
节点的查找
Find 是"查找指定值节点"的函数
先让 cur 指向树的根节点 _root ；
进入循环，只要 cur 不为空就持续查找：
若当前节点的键（ cur->_kv.first ）小于目标键 key ，就跳转到当前节点的右子树继续找；
若当前节点的键大于目标键 key ，就跳转到当前节点的左子树继续找；
若两者相等，说明找到目标节点，直接返回 cur ；
- 若循环结束（ cur 为空），说明树中没有该键对应的节点，返回 nullptr 。
它的作用是在二叉搜索树结构中，利用"左小右大"的特性快速定位目标节点。
计算AVL树节点总数
_Size 用于计算二叉树节点总数 的递归函数
递归终止条件：若当前节点 root 为空（ nullptr ），返回0（表示空树的节点数为0）；
递归计算逻辑：若当前节点非空，返回"左子树节点数 + 右子树节点数 + 1（当前节点本身）"。
该函数的作用是通过递归遍历二叉树的所有节点，统计出树的总节点数量，是二叉树基础操作中"统计规模"的常用实现方式。
计算AVL树高度
_Height 是用于计算二叉树高度的递归函数
终止条件：若当前节点 root 为空（ nullptr ），返回0（空树的高度为0）；
递归计算：
**- 先递归计算当前节点左子树的高度，结果存入 leftHeight ；
- 再递归计算当前节点右子树的高度，结果存入 rightHeight ；**
- 返回结果：取左、右子树高度的较大值，加1（当前节点本身的高度），作为当前树的高度。
该函数是二叉树基础操作之一，常用于AVL树等平衡树的平衡因子计算（平衡因子=左子树高度-右子树高度），是维护树平衡的关键辅助函数。
验证是否为AVL平衡树
_IsBalanceTree 是用于验证二叉树是否为AVL平衡树的递归函数
终止条件：若当前节点 root 为空，返回 true （空树默认是平衡树）；
计算高度与平衡因子：
-调用 _Height 函数，分别计算当前节点左、右子树的高度；
-计算实际平衡因子 bf （ bf = 右子树高度 - 左子树高度 ）；
- 校验平衡条件：
- 若实际平衡因子的绝对值≥2（树的高度差超过AVL树的允许范围），或实际 bf 与节点中存储的 root->_bf 不一致，输出"平衡因子异常"并返回 false ；
- 递归校验子树：
-递归校验当前节点的左子树和右子树，只有两者都平衡时，当前树才是平衡树。
该函数是AVL树的辅助验证工具，用于检查树是否满足"任意节点的左右子树高度差不超过1，且节点存储的平衡因子与实际高度差一致"的AVL树规则，确保树的结构符合平衡要求。
中序遍历
_InOrder 是二叉树的中序遍历函数
终止条件：若当前节点 root 为空，直接返回（空节点无内容可遍历）；
遍历顺序：
先递归遍历当前节点的左子树；
再输出 当前节点的键值对（ root->_kv.first 为键， root->_kv.second 为值）；
最后递归遍历当前节点的右子树。
中序遍历是二叉树的基础遍历方式之一，对于二叉搜索树（包括AVL树），中序遍历的结果会按"键的升序"输出，因此该函数常用于验证二叉搜索树的有序性，或按顺序获取树中的数据。
需要注意的是 , 我们把上面几个函数设为了私有函数 , 但是又用了共有函数对其进行了封装
把实现细节（比如操作 root 的 _Size ）设为私有，再用公有函数封装，外部就无法直接操作 root ，只能通过公有接口间接使用功能------既避免了外部误改 root 破坏树结构，也隐藏了"树的根节点"这个内部数据。
三、验证代码是否可以构建出AVL树
简单验证
- 那么此时我们实现了一个基本的AVL树，接下来我们使用第一组数据验证一下
每次插入元素后， IsBalanceTree() 返回 1 （表示树始终保持平衡 ），说明AVL树的插入+平衡调整逻辑正常；
中间 t.InOrder() 的输出（按键升序排列），符合二叉搜索树中序遍历的有序性；
下方 1 ：最终 IsBalanceTree() 的返回值，确认整个插入过程后树仍处于平衡状态。
- 再使用第二组数据验证一下
更严格更随机更大量的数据进行验证
- 其实仅仅靠上面给出的两组数据不能够验证所编写的AVLTree代码的正确性，还需要更严格更随机更大量的数据进行验证，这里先使用srand函数设置好随机数种子，然后使用rand函数随机生成一千万的随机数数据构成AVLTree进行验证正确性
生成100万个随机数据（存入 vector ）；
统计AVL树插入这些数据的耗时、插入后树的平衡性、高度、节点数；
统计对这些数据（含随机值）的查找耗时。
右侧输出对应代码中的打印项：
- Insert:228 ：插入100万数据的耗时 （单位为时钟周期）；
-1 ： IsBalanceTree() 返回值，说明插入后树仍平衡 ；
Height:22 ：AVL树的高度（100万节点的平衡树高度约为20级，符合对数级增长特性） ；
Size:635379 ：树的节点数（因随机数可能重复，实际插入数少于100万） ；
Find:177 ：查找操作的耗时，体现AVL树"对数级查找效率"的优势 。
该测试的作用是验证AVL树在大数据量场景下的实用性：既保持了高度平衡（保证操作效率），又能高效完成插入、查找等操作。
四、源代码
AVLTree.h
cpp
#pragma once
#include<assert.h>
template<class K, class V>
struct AVLTreeNode
{
// 需要parent指针，后续更新平衡因子可以看到
pair<K, V> _kv;
AVLTreeNode<K, V>* _left;
AVLTreeNode<K, V>* _right;
AVLTreeNode<K, V>* _parent;
int _bf; // (平衡因子)balance factor
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:
AVLTree()
:_root(nullptr)
{}
public:
bool Insert(const 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);
cur->_bf = 0;
if (parent->_kv.first < kv.first)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
while (parent)
{
if (cur == parent->_right)
{
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)
{
RotateR(parent);
}
else if (parent->_bf == 2 && cur->_bf == 1)
{
RotateL(parent);
}
else if (parent->_bf == -2 && cur->_bf == 1)
{
RotateLR(parent);
}
else if (parent->_bf == 2 && cur->_bf == -1)
{
RotateRL(parent);
}
else
{
assert(false);
}
break;
}
else
{
// 插入之前这棵树就有2/-2 bf的节点，这棵树之前就不是AVL树
assert(false);
}
}
return true;
}
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_kv.first < key)
{
cur = cur->_right;
}
else if (cur->_kv.first > key)
{
cur = cur->_left;
}
else
{
return cur;
}
}
return nullptr;
}
int Size()
{
return _Size(_root);
}
int Height()
{
return _Height(_root);
}
bool IsBalanceTree()
{
return _IsBalanceTree(_root);
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
private:
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
Node* parentParent = parent->_parent;
subL->_right = parent;
parent->_parent = subL;
if (parent == _root)
{
_root = subL;
subL->_parent = nullptr;
}
else
{
if (parentParent->_left == parent)
{
parentParent->_left = subL;
}
else
{
parentParent->_right = subL;
}
subL->_parent = parentParent;
}
parent->_bf = subL->_bf = 0;
}
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
Node* parentParent = parent->_parent;
subR->_left = parent;
parent->_parent = subR;
if (parent == _root)
{
_root = subR;
subR->_parent = nullptr;
}
else
{
if (parentParent->_left == parent)
{
parentParent->_left = subR;
}
else
{
parentParent->_right = subR;
}
subR->_parent = parentParent;
}
subR->_bf = parent->_bf = 0;
}
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(subL);
RotateR(parent);
if (bf == 0)
{
subL->_bf = 0;
parent->_bf = 0;
subLR->_bf = 0;
}
else if (bf == 1)
{
subL->_bf = -1;
parent->_bf = 0;
subLR->_bf = 0;
}
else if (bf == -1)
{
subL->_bf = 0;
parent->_bf = 1;
subLR->_bf = 0;
}
else
{
assert(false);
}
}
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(parent->_right);
RotateL(parent);
if (bf == 0)
{
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1)
{
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = -1;
}
else if (bf == -1)
{
subR->_bf = 1;
subRL->_bf = 0;
parent->_bf = 0;
}
else
{
assert(false);
}
}
int _Size(Node* root)
{
return root == nullptr ? 0 : _Size(root->_left) + _Size(root->_right) + 1;
}
int _Height(Node* root)
{
if (root == nullptr)
return 0;
int leftHeight = _Height(root->_left);
int rightHeight = _Height(root->_right);
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
bool _IsBalanceTree(Node* root)
{
if (root == nullptr)
return true;
int leftHeight = _Height(root->_left);
int rightHeight = _Height(root->_right);
int bf = rightHeight - leftHeight;
if (abs(bf) >= 2 || bf != root->_bf)
{
cout << root->_kv.first << "平衡因子异常" << endl;
return false;
}
return _IsBalanceTree(root->_left)
&& _IsBalanceTree(root->_right);
}
void _InOrder(Node* root)
{
if (root == nullptr)
return;
_InOrder(root->_left);
cout << root->_kv.first << ":" << root->_kv.second << endl;
_InOrder(root->_right);
}
private:
Node* _root;
};test.cpp
cpp
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
using namespace std;
#include"AVLTree.h"
void TestAVLTree1()
{
AVLTree<int, int> t;
// 常规的测试用例
int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
// 特殊的带有双旋场景的测试用例
//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
for (auto e : a)
{
t.Insert({ e, e });
//t.InOrder();
cout << "Insert:" << e << "->" << t.IsBalanceTree() << endl;
}
t.InOrder();
cout << t.IsBalanceTree() << endl;
}
// 插入一堆随机值，测试平衡，顺便测试一下高度和性能等
void TestAVLTree2()
{
const int N = 1000000;
vector<int> v;
v.reserve(N);
srand(time(0));
for (size_t i = 0; i < N; i++)
{
v.push_back(rand() + i);
}
size_t begin2 = clock();
AVLTree<int, int> t;
for (auto e : v)
{
t.Insert(make_pair(e, e));
}
size_t end2 = clock();
cout << "Insert:" << end2 - begin2 << endl;
cout << t.IsBalanceTree() << endl;
cout << "Height:" << t.Height() << endl;
cout << "Size:" << t.Size() << endl;
size_t begin1 = clock();
// 确定在的值
/*for (auto e : v)
{
t.Find(e);
}*/
// 随机值
for (size_t i = 0; i < N; i++)
{
t.Find((rand() + i));
}
size_t end1 = clock();
cout << "Find:" << end1 - begin1 << endl;
}
int main()
{
TestAVLTree1();
return 0;
}