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

news2024/12/28 2:53:45

请添加图片描述

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

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

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

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

文章目录

  • 前文
    • 一、AVL树概念
  • 二、AVL树实现
    • 2.1 AVL树节点的定义 (成员默认访问公有)
    • 2.2 AVL树查找逻辑
    • 2.3 AVL树插入逻辑
  • 三、AVL的旋转(重点)
    • 3.1 选用抽象图探讨AVL旋转
    • 3.2 单旋问题
      • 3.2.1 新节点插入较高左子树的左侧--左左:右单旋
      • 3.2.2 新节点插入较高右子树的右侧--右右:左单旋
    • 3.3 双旋解决问题
      • 3.3.1 新节点插入较高左子树的右侧--左右:先左单旋再右单旋
      • 3.3.2 根据结论修改AVL树节点平衡因子
      • 3.3.3 新节点插入较高右子树的左侧---右左：先右单旋再左单旋
      • 3.3.4 小总结
  • 四、AVL树的验证
    • 4.1 验证其为二叉搜索树
    • 4.2 验证其为平衡树
  • 五、AVL树的删除(了解 )
  • 六、AVL树的性能
  • 七、AVLTree.h

前文

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

因此，两位俄罗斯的数学家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)
            {}
    };

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

考虑到AVLTreeNode<K ,V>书写麻烦，使用typedef进行类型重定义typedef AVLTreeNode<K, V> 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;
	}

本质上来说AVL树属于二叉搜索树，关于cur->_kv.first是cur通过指针去访问Node类中类型为pair<K, V>对象的_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
             {//.............}
}

理解:

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

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

  • 父亲平衡因子 == 0，父亲所在子树高度不变，不再继续往上更新，插入结束
  • 父亲平衡因子 == 1 or -1, 父亲所在子树高度变了，继续往上更新上面节点的平衡因子
  • 父亲平衡因子 == 2 or -2, 父亲所在的子树已经不平衡了，需要旋转处理

三、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;
}

通过旋转使得不平衡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;
}

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);
    }
}

3.3.4 小总结

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

  1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR
  • 当pSubR的平衡因子为1时，执行左单旋
  • 当pSubR的平衡因子为-1时，执行右左双旋
  1. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL
  • 当pSubL的平衡因子为-1是，执行右单旋
  • 当pSubL的平衡因子为1时，执行左右双旋

旋转完成后，原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);
}

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

4.2 验证其为平衡树

规则:

  • 每个节点子树高度差的绝对值不超过1(注意节点种种那个如果没有平衡因子)
  • 节点的平衡因子是否计算正确
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);
}

五、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;
}

七、AVLTree.h

#pragma once
#include <assert.h>
#include <iostream>
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;
}

在这里插入图片描述
以上就是本篇文章的所有内容，在此感谢大家的观看！这里是店小二呀高阶数据结构笔记，希望对你在学习C++语言旅途中有所帮助！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2194285.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

828华为云征文｜华为云Flexus云服务器X实例部署 即时通讯IM聊天交友软件——高性能服务器实现120W并发连接

828华为云征文｜华为云Flexus云服务器X实例部署 即时通讯IM聊天交友软件——高性能服务器实现120W并发连接

营运版的即时通讯IM聊天交友系统&#xff1a;特点可发红包&#xff0c;可添加多条链接到用户网站和应用&#xff0c;安卓苹果APPPC端H5四合一 后端开发语言&#xff1a;PHP&#xff0c; 前端开发语言&#xff1a;uniapp混合开发。 集安卓苹果APPPC端H5四合一APP源码&#xff0…
阅读更多...
AI学习记录 - L2正则化详细解释（权重衰减）

AI学习记录 - L2正则化详细解释（权重衰减）

大白话&#xff1a; 通过让反向传播的损失值变得比原来更大&#xff0c;并且加入的损失值和权重的大小有关&#xff0c;当出现权重的平方变大的时候&#xff0c;也就是权重往更加负或者更加正的方向走的时候&#xff0c;损失就越大&#xff0c;从而控制极大正或者极大负的情况…
阅读更多...
在宝塔面板中部署 Express + MongoDB + Uniapp h5 项目（超详细！！！）

在宝塔面板中部署 Express + MongoDB + Uniapp h5 项目（超详细！！！）

文章目录 一、打包 uniapp h5 项目(1) 打开 manifest.json 文件&#xff0c;修改相关配置(2) 开始项目打包 二、修改 express 相关配置(1) 添加打包后的前端资源文件(2) 修改 app.js 文件(3) 修改项目启动命令 三、使用宝塔面板部署项目(1) 宝塔面板安装(2) 项目环境搭建 四、添…
阅读更多...
之前各种炸裂的Flux更新了Flux1.1 pro，效果会不会依然“炸裂”呢？

之前各种炸裂的Flux更新了Flux1.1 pro，效果会不会依然“炸裂”呢？

&#x1f420;更新内容 Black Forest Labs&#xff0c;也就是黑森林工作室在国庆期间更新了新的模型&#xff0c;Flux1.1 Pro&#xff0c;官方公告大家也可以参考&#xff1a; announcements. - Black Forest Labs 那么这次更新主要讲了什么呢&#xff1f; FLUX1.1 [pro]&am…
阅读更多...
系统架构设计师-下午案例题（2018年下半年）

系统架构设计师-下午案例题（2018年下半年）

1.某文化产业集团委托软件公司开发一套文化用品商城系统，业务涉及文化用品销售、定制、竞拍和点评等板块，以提升商城的信息化建设水平。该软件公司组织项目组完成了需求调研，现已进入到系统架构设计阶段。考虑到系统需求对架构设计决策的影响，项目组先列出了可能影响系统架…
阅读更多...
企业人力资源管理，人事档案管理，绩效考核，五险一金，招聘培训，薪酬管理一体化管理系统（源码）

企业人力资源管理，人事档案管理，绩效考核，五险一金，招聘培训，薪酬管理一体化管理系统（源码）

EHR人力资源管理系统是现代企业提升人力资源管理效率的重要工具。该系统集成了多个功能模块&#xff0c;旨在实现人力资源管理的全面数字化和自动化。以下是对EHR系统主要功能的剖析&#xff0c;包括组织架构、人事管理、考勤管理、薪资管理、绩效管理、档案管理、招聘管理、培…
阅读更多...
如何写出更系统的验证检查器

如何写出更系统的验证检查器

前言 芯片验证是为了发现芯片中的错误而执行的过程&#xff0c;它是一个破坏性的过程。有效激励灌入待测模块后&#xff0c;需要判断出不符合功能描述的行为。检查器(Checker)就是用于查看待测模块是否按照功能描述文档做出期望的行为&#xff0c;识别出所有的设计缺陷。 不同…
阅读更多...
【PostgreSQL】PG数据库表“膨胀”粗浅学习

【PostgreSQL】PG数据库表“膨胀”粗浅学习

文章目录 1 为什么需要关注表膨胀&#xff1f;2 如何确定是否发生了表膨胀&#xff1f;2.1 通过查询表的死亡元组占比情况来判断膨胀率2.1.1 指定数据库和表名2.1.2 查询数据库里面所有表的膨胀情况 3 膨胀的原理3.1 什么是膨胀&#xff1f;膨胀率&#xff1f;3.2 哪些数据库元…
阅读更多...
服贸会上的科技闪耀之星：璞华易研PLM系统引领产品研发潮流

服贸会上的科技闪耀之星：璞华易研PLM系统引领产品研发潮流

2024年中国国际服务贸易交易会&#xff08;以下简称为“服贸会”&#xff09;于9月在北京盛大开幕&#xff0c;再次汇聚全球目光&#xff0c;共襄智慧服务的盛宴。本届服贸会秉承“全球服务、互惠共享”的核心理念&#xff0c;聚焦“共享智慧服务&#xff0c;共促开放发展”&am…
阅读更多...
计算机毕业设计 基于Python的社交音乐分享平台的设计与实现 Python+Django+Vue 前后端分离 附源码 讲解 文档

计算机毕业设计 基于Python的社交音乐分享平台的设计与实现 Python+Django+Vue 前后端分离 附源码 讲解 文档

&#x1f34a;作者&#xff1a;计算机编程-吉哥 &#x1f34a;简介&#xff1a;专业从事JavaWeb程序开发&#xff0c;微信小程序开发&#xff0c;定制化项目、 源码、代码讲解、文档撰写、ppt制作。做自己喜欢的事&#xff0c;生活就是快乐的。 &#x1f34a;心愿&#xff1a;点…
阅读更多...
【路径规划】A*（A星）搜索路径规划教程

【路径规划】A*（A星）搜索路径规划教程

摘要 A算法是一种用于图形搜索的启发式搜索算法&#xff0c;广泛应用于路径规划、游戏AI和机器人导航等领域。本教程将深入介绍A算法的理论基础&#xff0c;展示其在路径规划中的应用&#xff0c;并通过Matlab代码实现A*算法的实际运行。同时&#xff0c;我们将结合实验结果进…
阅读更多...
qsort函数及其使用的方法分解讲解

qsort函数及其使用的方法分解讲解

qsort函数 默认排序升序 void qsort(void* base,//指向待排序数组的第一个元素的地址 size_t num,//base指向数组中元素的个数 size_t size,//base指向的数组中一个元素的大小&#xff0c;单位是字节 int (*compar)(const void*,const void*…
阅读更多...
YOLO11改进|卷积篇|引入线性可变形卷积LDConv

YOLO11改进|卷积篇|引入线性可变形卷积LDConv

目录 一、【LDConv】卷积1.1【LDConv】卷积介绍1.2【LDConv】核心代码 二、添加【LDConv】卷积2.1STEP12.2STEP22.3STEP32.4STEP4 三、yaml文件与运行3.1yaml文件3.2运行成功截图 一、【LDConv】卷积 1.1【LDConv】卷积介绍 下图是【LDCNV】的结构图&#xff0c;让我们简单分析…
阅读更多...
Mysql高级篇（下）——主从复制

Mysql高级篇（下）——主从复制

主从复制 一、概述二、作用&#x1f388; 场景示例&#x1f388; 综合示例 三、原理&#x1f388; 主从复制基本原则&#x1f388; 主从复制存在的问题 四、一主一从架构搭建&#x1f331;准备工作&#x1f31e;步骤1. 配置主库&#xff08;Master&#xff09;2. 配置从库&…
阅读更多...
如何搭建基于大模型的智能知识库

如何搭建基于大模型的智能知识库

自从2022年底ChatGPT横空出世引爆了大模型技术浪潮&#xff0c;时至今日已经一年有余&#xff0c;如何从技术侧向商业侧落地转化是一直以来业内普遍关注的问题。 从目前企业端观察到的情况来看&#xff0c;基于大模型的知识库是一个比较有潜力和价值的应用场景&#xff0c;能够…
阅读更多...
落伍警告：不了解AI Agent，你可能会被编程界淘汰

落伍警告：不了解AI Agent，你可能会被编程界淘汰

AI Agent火爆到什么程度&#xff1f; OpenAI创始人奥特曼预测&#xff0c;未来各行各业&#xff0c;每一个人都可以拥有一个AI Agent&#xff1b;比尔盖茨在2023年层预言&#xff1a;AI Agent将彻底改变人机交互方式&#xff0c;并颠覆整个软件行业&#xff1b;吴恩达教授在AI…
阅读更多...
UE5 武器IK瞄准系统

UE5 武器IK瞄准系统

创建空项目 创建基础蓝图类My_GameMode，My_HUD，My_PlayChar，My_PlayController 项目设置地图模式 近裁平面 0.1 My_PlayChar蓝图中添加摄像机，角色骨骼网格体，武器骨骼网格体 编辑角色骨骼，预览控制器使用特定动画，动画选择ANM_ark-47-Idle hand_r 添加插槽WeaponMes…
阅读更多...
Stable Diffusion绘画 | 如何做到不同动作表情，人物角色保持一致性（下篇）

Stable Diffusion绘画 | 如何做到不同动作表情，人物角色保持一致性（下篇）

在 人物角色保持一致性&#xff08;上篇&#xff09;中&#xff0c;我们已经得到了自己创造的角色的各个角度头像图片&#xff1a; 从中选择一个符合自己需求的角度&#xff0c;截图保存&#xff0c;例如下图&#xff1a; 更换人物表情 进入到「图生图」页面&#xff0c;把上一…
阅读更多...
短视频时代，网站建设存在的意义还有多大？

短视频时代，网站建设存在的意义还有多大？

在短视频时代&#xff0c;网站建设的存在意义依然具有多方面的价值和作用。尽管短视频作为一种新兴的传播方式迅速发展并受到广泛欢迎&#xff0c;但网站作为互联网的基础设施之一&#xff0c;仍然在许多领域发挥着不可替代的作用。以下是具体分析&#xff1a; 信息深度与完整性…
阅读更多...
医院管理新思维：Spring Boot技术应用

医院管理新思维：Spring Boot技术应用

5系统详细实现 5.1 医生模块的实现 5.1.1 病床信息管理 医院管理系统的医生可以管理病床信息&#xff0c;可以对病床信息添加修改删除操作。具体界面的展示如图5.1所示。 图5.1 病床信息管理界面 5.1.2 药房信息管理 医生可以对药房信息进行添加&#xff0c;修改&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023