【高阶数据结构】二叉树进阶探秘：AVL树的平衡机制与实现详解

id="article_content" class="article_content clearfix" style="height: 2000px; overflow: hidden;"> id="content_views" class="markdown_views prism-kimbie-light">

请添加图片描述

class="table-box">
高阶数据结构相关知识点可以通过点击以下链接进行学习一起加油！
二叉搜索树

大家好，这里是店小二！今天我们将深入探讨高阶数据结构中的AVL树。AVL树是一种自平衡的二叉搜索树，可以看作是对传统二叉搜索树的优化版本。如果你对数据结构感兴趣，快拿出你的小本本，和我们一起开始这段探索之旅吧！

请添加图片描述
Alt
🌈个人主页：是店小二呀
🌈C语言专栏：C语言
🌈C++专栏： C++
🌈初阶数据结构专栏： 初阶数据结构
🌈高阶数据结构专栏： 高阶数据结构
🌈Linux专栏： Linux

🌈喜欢的诗句:无人扶我青云志 我自踏雪至山巅 请添加图片描述

class="toc">

文章目录

前文

关于上篇二叉搜索树性能那块，探讨了二叉搜索树虽然可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。

因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度，按照这种规则形成的二叉搜索树为AVL树，保持着严格的平衡。

一、AVL树概念

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

  • 它的左右子树都是AVL树
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
  • 平衡因子并不是必须，只是他的一种实现方式

在这里插入图片描述
在这里插入图片描述

如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在logn,搜索时间复杂度O(logn)

平衡因子计算:

  • 平衡因子 = 右子树高度 - 左子树高度

二、AVL树实现

2.1 AVL树节点的定义 (成员默认访问公有)

template<class K, class V>
    struct AVLTreeNode
    {
        AVLTreeNode<K, V>* _left;
        AVLTreeNode<K, V>* _right;
        AVLTreeNode<K, V>* _parent;

        pair<K, V> _kv;
        int _bf;

        //主要类型
        AVLTreeNode(const pair<K, V> & kv)
            :_left(nullptr)
                ,_right(nullptr)
                ,_parent(nullptr)
                ,_kv(kv)
                ,_bf(0)
            {}
    };
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

AVL树每个结构存储一个pair对象，其中需要parent指针目的是为了方便访问当前节点的上一个节点。

考虑到AVLTreeNode书写麻烦，使用typedef进行类型重定义typedef AVLTreeNode Node;

2.2 AVL树查找逻辑

	Node* Find(const K& key)
	{
		//按照搜索树
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_kv.first)
			{
				cur = cur->_right;
			}
			else if (key < cur->_kv.first)
			{
				cur = cur->_left;
			}
			else
			{
				//返回当前节点的指针
				return cur;
			}
		}
        //防止意外发生。
		return nullptr;
	}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

本质上来说AVL树属于二叉搜索树，关于cur->_kv.first是cur通过指针去访问Node类中类型为pair对象的_kv。通过set与map简单学习。可以得知pair内部实现逻辑，_这里的kv.first中first是K类型的对象。同时AVL也是二叉树搜索树，查找逻辑当然是使用二叉搜索树的逻辑。

2.3 AVL树插入逻辑

既然AVL也是二叉搜索树，那么插入逻辑也是一样的，不同在于需要进行平衡因子的调正。(平衡因子 = 右子树高度 - 左子树高度)

当插入节点结束后，对插入节点的父亲节点进行平衡因子的修改。当对于父亲节点达到特定值会对应不同的情况，不断利用parent向上调整父亲节点的平衡因子。

通过例图去分析，当父亲平衡因子到达特定值对应不同情况:

第一张:当parent平衡因子从1或-1变到0

在这里插入图片描述

第二张:这里出现两种情况，parent平衡因子从0变到1或-1，parent平衡因子从1或-1变到2或-2。只有从0变到1或-1，没有从2或-2变成1或-1，因为当parent平衡因子绝对值超过1时，已经出现问题，需要进行调正

在这里插入图片描述

具体说明:

  1. 按照搜索树规则插入
  2. 某个父亲节点的平衡因子
    • 插入父亲的左孩子，父亲平衡因子–
    • 插入父亲的右孩子，父亲平衡因子++
while (parent)
{
    //规矩平衡因子的规则，是根据特性和下面代码得来的
    if (parent->_left == cur)
    {
        parent->_bf--;
    }
    else if (parent->_right == cur)
    {
        parent->_bf++;
    }

    //判断是否回到父亲节点改动
    if (parent->_bf == 0)
    {
        //没有啥问题，可以跳出程序
        break;
    }
    else if (parent->_bf == 1 || parent->_bf == -1)
    {
        cur = parent;
        parent = parent->_parent;
    }
    //出现问题,这种情况是由情况二变化过来的，那么就是说，cur和parent向上移动了
    else if (parent->_bf == 2 || parent->_bf == -2
             {//.............}
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

理解:

在节点插入后，需要进行平衡因子的更新。更新顺序是从下到上，结合着父亲节点平衡因子进行判断是否需要继续向上更新。

根据判断更新父亲的平衡因子状况进行处理(该平衡因子更新完后):

三、AVL的旋转(重点)

如果在一颗原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种:

在这里插入图片描述

这里可以将前面两种归为单旋进行处理，而后面两种需要通过双旋进行处理。

提前说明:一个AVL树有多个AVL树或者说一个复杂的AVL树是由许多个简单的AVL树进行组合而成的。那么如果插入一个节点导致AVL树失去平衡，这里AVL树指以插入节点的父亲节点为根节点的子AVL树。遵守一个有问题解决问题，如果只是这一课AVL树有问题，就解决这颗AVL树，正常的AVL树我们是不要去过多的进行处理。

根据说明，如果将一整棵AVL树全部拆分进行研究，不同节点插入的位置很多选择，情况有很多种，难以全部罗列出来，而且没有必要，如果将一颗有问题AVL树治好，就可以将任何一颗AVL树治好，所以这边采用使用抽象图进行分析。

3.1 选用抽象图探讨AVL旋转

其中使用a、b、c子AVL树及其高度设置为h

在这里插入图片描述

在这里插入图片描述

抽象图中的抽象的AVL树平衡因子这里不用看的，目前罗列的情况是可以包含这里的，这里小部分就是大部分调正平衡因子的过程，意味着这部分也可以是抽象AVL树中的情况按照当前处理已经进行了调整。

3.2 单旋问题

使用单旋场景:parent->_bf == 2 && cur->_bf == 1或者parent->_bf == -2 && cur->_bf == -1

3.2.1 新节点插入较高左子树的左侧–左左:右单旋

场景:parent->_ bf == -2 && cur->_bf == -1

在这里插入图片描述

在这里插入图片描述

具体解析旋转步骤:

目前AVL树是平衡的，当插入新节点30到左子树中，左子树高度加一层，导致以60为根的子AVL树失去平衡。为了使得平衡，意味着节点60的右子树也需要增加一层，那么将60节点成为30节点的左孩子，同时原本30节点的左孩子和60节点成为30节点的左孩子的高度相同，那么将原本30节点的左孩子成为60节点有孩子。这里保证了30节点原本左孩子一定是小于60节点的。更新节点的平衡因子即可，简单概况就是30 < b子树 < 60 < c子树

旋转过程中，有以下几点情况需要考虑:

  1. 30节点的右孩子可能存在，也可能不存在
  2. 60可能是根节点，也可能是子树
    • 如果是根节点，旋转完成后，要更新根节点
    • 如果是子树，可能是某个节点的左子树，也可能是右子树
void RotateR(Node* parent)
{
    Node* SubL = parent->_left;
    Node* SubLR = SubL->_right;

    parent->_left = SubLR;
    if (SubLR)
        SubLR->_parent = parent;

    SubL->_right = parent;
    Node* ppNode = parent->_parent;

    parent->_parent = subL;
    if (parent == _root)
    {
        SubL = _root;
        SubL->_parent = nullptr;
    }
    else
    {
        if (ppNode->_left == parent)
        {
            ppNode->_left = SubL;
        }
        else if(ppNode->_right == parent)
        {
            ppNode->_right = SubL;
        }
        SubL->_parant = ppNode;
    }
    SubL->_bf = 0;
    parent->_bf = 0;
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

通过旋转使得不平衡AVL树得到调整，这里不需要考虑向上更新平衡因子。从抽象图中可以得出旋转后结论，直接使用结论修改平衡因子就行。

3.2.2 新节点插入较高右子树的右侧–右右:左单旋

场景:parent->_ bf == 2 && cur->_bf == 1

在这里插入图片描述

这里和右单旋是差不多的，具体流程可以去看上述和代码分析

在这里插入图片描述

void RotateL(Node* parent)
{
    Node* SubR = parent->_right;
    Node* SubRL = SubR->_left;

    parent->_right = SubRL;
    if (SubRL)
        SubR->_parent = parent;

    SubR->_left = parent;
    Node* ppNode = parent->_parent;

    parent->_parent = subR;

    if (parent == _root)
    {
        SubR = _root;
        SubR->_parent = nullptr;
    }
    else
    {
        if (ppNode->_left == parent)
        {
            ppNode->_left = SubR;
        }
        else if (ppNode->_right == parent)
        {
            ppNode->_right = SubR;
        }
        SubR->_parant = ppNode;
    }
    SubR->_bf = 0;
    parent->_bf = 0;
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

3.3 双旋解决问题

如果出现了这种if (parent->_bf == 2 || cur->_bf == -1), if (parent->_bf == -2 || cur->_bf == 1)普通单旋是不能解决问题的，需要使用到双旋。

如果使用单旋的话是没有多大作用的，做无用功。我们使用单旋处理的情况是一边独高，而不是那边高，这边高。对此可以先对内部旋转变成单独一边高，再使用单旋进行调整AVL树。

在这里插入图片描述

3.3.1 新节点插入较高左子树的右侧–左右:先左单旋再右单旋

场景:parent->_bf == -2 && cur->_bf == 1

在这里插入图片描述
在这里插入图片描述

这里可以直接复用实现好单旋的接口，但是需要对平衡因子进行调整，这里平衡因子可以通过结论直接修改。

3.3.2 根据结论修改AVL树节点平衡因子

通过图中对于不同情况的分析，对于修改平衡因子的结果是根据SubLR平衡因子特殊值决定的。b、c分别给谁，会影响平衡因子的分配。

在这里插入图片描述

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

场景:parent->_bf == 2 && cur->_bf == -1

在这里插入图片描述

这里还是需要根据60这块的平衡因子去判断的，b c分别给谁，会影响平衡因子的分配。左边新增两次旋转给到右边，右边新增两次旋转给到左边，通过结论最后修改平衡因子。

void RotateRL(Node* parent)
{

    Node* subR = parent->_right;
    Node* subRL = subR->_left;
    int bf = subRL->_bf;

    RotateR(subR);
    RotateL(parent);

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

}

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
    {
        assert(false);
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

3.3.4 小总结

假如以pParent为根的子树不平衡，即pParent的平衡因子为2或者-2，分以下情况考虑 ：

  1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR
  1. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL

旋转完成后，原pParent为根的子树个高度降低，已经平衡，不需要再向上更新

四、AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分为两步:验证是否为二叉搜索树，验证是否为平衡树

4.1 验证其为二叉搜索树

如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

void InOder()
{
    _InOder(_root);
    cout << endl;
}

private:
void _InOder(Node* _root)
{
    if (_root == nullptr)
    {
        return;
    }
    
    InOder(_root->_left);
    cout << _root->_kv.first << " " << _root->_kv.second << endl;
    InOder(_root->_right);
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

这里将中序遍历实现逻辑封装到私有成员函数中隐藏它的具体实现细节，使得外部用户无法直接访问该函数，提高了代码的安全性和可维护性，符合面向对象编程的封装性原则。这里外部访问中序遍历接口，只是传递了节点指针的副本，而不修改任何节指针的实际值。

4.2 验证其为平衡树

规则:

bool IsBalance()
{
    return _IsBalance(_root);
}

int Height()
{
    return _Height(_root);
}

int Size()
{
    return _Size(_root);
}

private:
int _Size(Node* root)
{
    return root == nullptr ? 0 : _Size(root->_left) + _Size(root->_right) + 1;
}

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

    return max(_Height(root->_left), _Height(root->_right)) + 1;
}

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

    int leftHeight = _Height(root->_left);
    int rightHeight = _Height(root->_right);
    // 不平衡
    if (abs(leftHeight - rightHeight) >= 2)
    {
        cout << root->_kv.first << endl;
        return false;
    }

    // 顺便检查一下平衡因子是否正确
    if (rightHeight - leftHeight != root->_bf)
    {
        cout << root->_kv.first << endl;
        return false;
    }

    return _IsBalance(root->_left)
        && _IsBalance(root->_right);
}

void _InOder(Node* _root)
{
    if (_root == nullptr)
    {
        return;
    }

    InOder(_root->_left);
    cout << _root->_kv.first << " " << _root->_kv.second << endl;
    InOder(_root->_right);
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

五、AVL树的删除(了解 )

因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置 ，这里调正平衡因子的逻辑就需要反过来，同时参考下二叉搜索树的删除操作。

六、AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即O(log^n^)`。但是如果要对AVL树做一些结构修改的操作，性能非常低下。

插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合

补充调式小技巧:

void TestAVLTree1()
{
    //int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
    int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
    AVLTree<int, int> t1;
    for (auto e : a)
    {
        /*if (e == 4)
		{
			int i = 0;
		}*/

        // 1、先看是插入谁导致出现的问题
        // 2、打条件断点，画出插入前的树
        // 3、单步跟踪，对比图一一分析细节原因
        t1.Insert({e,e});

        cout <<"Insert:"<< e<<"->"<< t1.IsBalance() << endl;
    }

    t1.InOrder();

    cout << t1.IsBalance() << endl;
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

七、AVLTree.h

#pragma once
#include 
#include 
using namespace std;

//设置默认权限为公用的结构体
template<class K, class V>
    struct AVLTreeNode
    {
        AVLTreeNode<K, V>* _left;
        AVLTreeNode<K, V>* _right;
        AVLTreeNode<K, V>* _parent;

        pair<K, V> _kv;
        int _bf;

        //主要类型
        AVLTreeNode(const pair<K, V>& kv)
            :_left(nullptr)
                , _right(nullptr)
                , _parent(nullptr)
                , _kv(kv)
                , _bf(0)
            {}
    };

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

        bool Insert(const pair<K, V>& kv)
        {

            if (_root == nullptr)
            {
                _root = new Node(kv);
                return true;
            }

            //也是查找需要插入的地方，进行插入
            Node* parent = nullptr;
            Node* cur = _root;
            //目的就是让cur走到合适的空位置
            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
                {
                    assert(!cur);
                }
            }
            //需要将这个节点连接起来
            cur = new Node(kv);
            cur->_parent = parent;
            if (parent->kv.first > cur->_kv.first)
            {
                parent->_left = cur;
            }
            else if (parent->kv.first < cur->_kv.first)
            {
                parent->_right = cur;
            }
            //上述完成了插入的逻辑，调正平衡因子
            while (parent)
            {
                //平衡因子的规则
                if (parent->_left == cur)
                {
                    parent->_bf--;
                }
                else if (parent->_right == cur)
                {
                    parent->_bf++;
                }

                //判断是否回到父亲节点改动
                if (parent->_bf == 0)
                {
                    //没有啥问题，可以跳出程序
                    break;
                }
                else if (parent->_bf == 1 || parent->_bf == -1)
                {
                    cur = parent;
                    parent = parent->_parent;
                }
                //出现问题,这种情况是由情况二变化过来的，那么就是说，cur和parent向上移动了
                else if (parent->_bf == 2 || parent->_bf == -2)
                {
                    //这里根据规律，去固定改变平衡因子
                    if (parent->_bf == 2 && cur->_bf == 1)
                    {
                        RotateL(parent);
                    }
                    if (parent->_bf == -2 && cur->_bf == -1)
                    {
                        RotateR(parent);
                    }
                    //双旋
                    if (parent->_bf == 2 &&  cur->_bf == -1)
                    {
                        RotateRL(parent);
                    }
                    if (parent->_bf == -2 && cur->_bf == 1)
                    {
                        RotateLR(parent);
                    }
                    break;
                }
                else
                {
                    assert(false);
                }
            }
        }
        void RotateR(Node* parent)
        {
            Node* SubL = parent->_left;
            Node* SubLR = SubL->_right;

            parent->_left = SubLR;
            if (SubLR)
                SubLR->_parent = parent;

            SubL->_right = parent;
            Node* ppNode = parent->_parent;

            parent->_parent = SubL;
            if (parent == _root)
            {
                SubL = _root;
                SubL->_parent = nullptr;
            }
            else
            {
                if (ppNode->_left == parent)
                {
                    ppNode->_left = SubL;
                }
                else if (ppNode->_right == parent)
                {
                    ppNode->_right = SubL;
                }
                SubL->_parant = ppNode;
            }
            SubL->_bf = 0;
            parent->_bf = 0;
        }
        void RotateL(Node* parent)
        {
            Node* SubR = parent->_right;
            Node* SubRL = SubR->_left;

            parent->_right = SubRL;
            if (SubRL)
                SubR->_parent = parent;

            SubR->_left = parent;
            Node* ppNode = parent->_parent;

            parent->_parent = SubR;

            if (parent == _root)
            {
                SubR = _root;
                SubR->_parent = nullptr;
            }
            else
            {
                if (ppNode->_left == parent)
                {
                    ppNode->_left = SubR;
                }
                else if (ppNode->_right == parent)
                {
                    ppNode->_right = SubR;
                }
                SubR->_parant = ppNode;
            }
            SubR->_bf = 0;
            parent->_bf = 0;
        }

        void RotateRL(Node* parent)
        {

            Node* subR = parent->_right;
            Node* subRL = subR->_left;
            int bf = subRL->_bf;

            RotateR(subR);
            RotateL(parent);

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

        }

        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
            {
                assert(false);
            }
        }

        void InOder()
        {
            _InOder(_root);
            cout << endl;
        }
        bool IsBalance()
        {
            return _IsBalance(_root);
        }

        int Height()
        {
            return _Height(_root);
        }

        int Size()
        {
            return _Size(_root);
        }

        private:
        int _Size(Node* root)
        {
            return root == nullptr ? 0 : _Size(root->_left) + _Size(root->_right) + 1;
        }

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

            return max(_Height(root->_left), _Height(root->_right)) + 1;
        }

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

            int leftHeight = _Height(root->_left);
            int rightHeight = _Height(root->_right);
            // 不平衡
            if (abs(leftHeight - rightHeight) >= 2)
            {
                cout << root->_kv.first << endl;
                return false;
            }

            // 顺便检查一下平衡因子是否正确
            if (rightHeight - leftHeight != root->_bf)
            {
                cout << root->_kv.first << endl;
                return false;
            }

            return _IsBalance(root->_left)
                && _IsBalance(root->_right);
        }

        void _InOder(Node* _root)
        {
            if (_root == nullptr)
            {
                return;
            }

            InOder(_root->_left);
            cout << _root->_kv.first << " " << _root->_kv.second << endl;
            InOder(_root->_right);
        }
        private:
        Node* _root = nullptr;
    };

void AVLTest1()
{
    AVLTree<int, int> at;
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

在这里插入图片描述

以上就是本篇文章的所有内容，在此感谢大家的观看！这里是高阶数据结构笔记，希望对你在学习高阶数据结构旅途中有所帮助！

id="blogExtensionBox" style="width:400px;margin:auto;margin-top:12px" class="blog-extension-box"> class="blog_extension blog_extension_type2" id="blog_extension"> class="extension_official" data-report-click="{"spm":"1001.2101.3001.6471"}"> class="blog_extension_card_left"> class="blog_extension_card_cont"> 欢迎各位商业合作或学习交流 class="blog_extension_card_cont_r"> 微信名片
注：本文转载自blog.csdn.net的是店小二呀的文章"https://blog.csdn.net/2302_79177254/article/details/141822023"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！