AVL平衡搜索树

最新推荐文章于 2024-10-05 19:25:32 发布
原创 最新推荐文章于 2024-10-05 19:25:32 发布 · 434 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

这篇博客介绍了AVL树的基本概念和性质，包括平衡因子和插入节点后的旋转操作，如左单旋转、右单旋转、左右旋转和右左旋转。通过示例代码展示了AVL树节点的定义以及插入、查找、中序遍历和判断平衡的方法。

AVL树又称高度平衡的二叉搜索树。

性质：
     1. 左子树和右子树的高度之差的绝对值不超过1
     2. 树中的每个左子树和右子树都是AVL树
     3. 每个节点都有一个平衡因子(balance factor--bf),任一节点的平衡因子是-1,0,1。(每个节点的平衡因子等于右子树的高度减去左子树的高度 )

     当插入一个节点时，如果这个节点的父节点的平衡因子不满足AVL树的特点，这时就需要对AVL树进行调整，即旋转。

     1、左单旋转
     
2、右单旋转
        
3、左右旋转

4、右左旋转

实现代码如下：
#pragma once

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

    K _key;
    V _value;

    int _bf;//平衡因子
    AVLTreeNode(const K& key,const V& value)
        :_bf(0)
        ,_left(NULL)
        ,_right(NULL)
        ,_parent(NULL)
        ,_key(key)
        ,_value(value)
    { }
};

template<class K,class V>
class AVLTree
{
public:
    typedef AVLTreeNode<K,V> Node;
    AVLTree()
        :_root(NULL)
    { }

    bool Insert(const K& key,V& value)
    {
        if(_root == NULL)
        {
            _root = new Node(key,value);
            return true;
        }

        Node* cur = _root;
        Node* parent = NULL;

        while (cur)
        {
            if(cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if(cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;
            }
        }

        cur = new Node(key,value);
        if(parent->_key < key)
        {
            parent->_right = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_left = cur;
            cur->_parent = parent;
        }

        //检查树是否平衡
        //更新平衡因子，不满足条件时，进行旋转
        while (parent)
        {
            if(cur == parent->_left)
                parent->_bf--;
            else
                parent->_bf++;
            if(parent->_bf == 0)
                break;
            else if(parent->_bf == -1 || parent->_bf == 1)//回朔
            {
                cur = parent;
                parent = cur->_parent;
            }
            else//平衡因子为2或-2
            {
                if(cur->_bf == 1)
                {
                    if(parent->_bf == 2)
                        RotateL(parent);
                    else//-2
                        RotateLR(parent);
                }
                else
                {
                    if(parent->_bf == -2)
                        RotateR(parent);
                    else
                        RotateRL(parent);
                }
                break;
            }
        }
        return true;
    }

    Node* Find(const K& key)
    {
        if(_root == NULL)
            return NULL;
        Node* cur = _root;
        while (cur)
        {
            if(cur->_key < key)
            {
                cur = cur->_right;
            }
            else if(cur->_key > key)
            {
                cur = cur->_left;
            }
            else
            {
                return cur;
            }
        }
        return NULL;
    }

    void InOrder()
    {
        _InOrder(_root);
        cout<<endl;
    }

    bool IsBlance()
    {
        return _IsBlance(_root);
    }


    ~AVLTree()
    {
        _Destroy(_root);
        _root = NULL;
    }

protected:
    void RotateL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        parent->_right = subRL;
        if(subRL)
            subRL->_parent = parent;

        subR->_left = parent;

        Node* ppNode = parent->_parent;
        parent->_parent = subR;
        subR->_parent = ppNode;
        if(ppNode == NULL)
        {
            _root = subR;
        }
        else
        {
            if(ppNode->_left == parent)
                ppNode->_left = subR;
            else
                ppNode->_right = subR;
        }
        parent->_bf = subR->_bf = 0;
    }

    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;
        subL->_parent = ppNode;

        if(ppNode == NULL)
        {
            _root = subL;
        }
        else
        {
            if(ppNode->_left == parent)
                ppNode->_left = subL;
            else
                ppNode->_right = subL;
        }
        parent->_bf = subL->_bf = 0;
    }

    void RotateLR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR =subL->_right;
        int bf = subLR->_bf;

        RotateL(parent->_left);
        RotateR(parent);

        //根据subL的平衡因子修正其他节点的平衡因子
        if(bf == -1)
        {
            subL->_bf = 0;
            parent->_bf = 1;
        }
        else if(bf == 1)
        {
            subL->_bf = -1;
            parent->_bf = 0;
        }
        else
        {
            subL->_bf = parent->_bf = 0;
        }
    }

    void RotateRL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        int bf = subRL->_bf;
        RotateR(parent->_right);
        RotateL(parent);

        //根据subRL的平衡因子修正其它节点的平衡因子
        if(bf == 1)
        {
            subR->_bf = 0;
            parent->_bf = -1;
        }
        else if(bf == -1)
        {
            subR->_bf = 1;
            parent->_bf = 0;
        }
        else
        {
            parent->_bf = subR->_bf = 0;
        }
    }

    void _Destroy(Node* root)
    {
        if(root == NULL)
            return;
        _Destroy(root->_left);
        _Destroy(root->_right);
        delete root;
    }

    void _InOrder(Node* root)
    {
        if(root == NULL)
            return;
        _InOrder(root->_left);
        cout<<root->_key<<" ";
        _InOrder(root->_right);
    }

    int _Height(Node* root)
    {
        if(root == NULL)
            return 0;
        int Left = _Height(root->_left);
        int Right = _Height(root->_right);
        return (Left > Right) ? (Left + 1) : (Right + 1);
    }

    bool _IsBlance(Node* root)
    {
        if(root == NULL)
            return true;
        int left = _Height(root->_left);
        int right = _Height(root->_right);
        if((right - left) != root->_bf || abs(right - left) > 1)
        {
            cout<<"该节点的平衡因子异常:";
            cout<<root->_key<<" "<<endl;
            return false;
        }
        return _IsBlance(root->_left) && _IsBlance(root->_right);
    }

protected:
    Node* _root;
};

void AVLTreeTest()
{
    int a[] = {16, 3, 7, 11, 9, 26, 18, 14, 15};
    AVLTree<int,int> tree;
    for(int i = 0;i < 9;i++)
    {
        tree.Insert(a[i],i);
    }
    tree.InOrder();
    tree.Find(16);
    tree.IsBlance();

}

void TestTree_SP()
{
    int a[] = {4, 2, 6, 1, 3, 5, 15, 7, 16, 14};
    AVLTree<int, int> t;

    for (int i = 0; i < sizeof(a)/sizeof(a[0]); ++i)
    {
        t.Insert(a[i], i);
    }
    t.InOrder();
    t.IsBlance();
}


【数据结构】AVL树——平衡二叉搜索树
2301_79796701的博客
05-25 2152
平衡树：左子树的高度等于右子树的高度不平衡树：左子树的高度不等于等于右子树的高度二叉搜索树很难是一颗平衡树。对二叉树进行插入和删除的操作，或插入大量的数据不够随机，都会是使二叉搜索树不够平衡。极端情况下，二叉树会退化成类似链表的结构，那么二叉搜索树查询数据的效率荡然无存。在二叉树的基础上加入平衡的概念就是平衡二叉搜索树，也叫AVL树。AVL树也不是一颗绝对的平衡树，AVL树的平衡是相对的，它允许左子树和右子树的高度为 1 ，但不能超过 1。
平衡二叉（AVL）树
月守护的博客
12-15 1270
在前面的系列文章中，我们讲过了二叉查找树的相关知识和实现（二叉树（一）–概述（附二叉搜索树实现））。在文章的最后，我们总结了二叉查找树的查找时间复杂度： 对于一个节点分布相对均衡的二叉查找树来说，如果节点总数是n，那么搜索节点的时间复杂度是O（logn）,和树的深度是一样的。 但对于极端情况（每次插入数据大小都是增大的，或者减小的），外形上看就只有一半的树，查找时间复杂度就会退化成O（n）的 为了解决二叉查找树查找时间复杂度退化的问题，需要二叉数据的自平衡，也就是本节要讲的平衡二叉树。通过自身的平衡调整
AVL树及其搜索树
架构设计
03-27 307
首先我们先明确两个关于二叉树的基本概念：深度（depth）和高度（height）。 深度：从根节点开始（其深度为1），自顶向下逐层累加； 高度：从叶节点开始（其高度为1），自底向上逐层累加。 虽然树的高度和深度一样，但具体到某个节点，其深度和高度不一样，如： 节点10的高度为2，深度为3；节点7的高度为1，深度为3. 言归正传： AVL树：一个空二叉树是AVL树；一个非空二叉树T的...
终于搞懂了什么是二叉查找树，AVL树，B树，B+树，红黑树
热门推荐
wanderlustLee的博客
02-26 1万+
二叉查找树： 二叉查找树就是左结点小于根节点，右结点大于根节点的一种排序树，也叫二叉搜索树。也叫BST，英文Binary Sort Tree。 二叉查找树比普通树查找更快，查找、插入、删除的时间复杂度为O（logN）。但是二叉查找树有一种极端的情况，就是会变成一种线性链表似的结构。此时时间复杂度就变味了O（N），为了解决这种情况，出现了二叉平衡树。   平衡二叉树： 平衡二叉树全称平衡二...
AVL树（平衡二叉搜索树）
2301_81265915的博客
08-16 3553
int _bf;, _bf(0), _kv(kv){}某节点的左子树与右子树的高度(深度)差即为该节点的平衡因子（BF,Balance Factor），平衡二叉树中不存在平衡因子大于 1或小于-1的节点。在一棵平衡二叉树中，节点的平衡因子只能取 0 、1 或者 -1 ，分别对应着左右子树等高，左子树比较高，右子树比较高。
AVL——平衡搜索树
qq_63943454的博客
08-23 1380
AVL树是对二叉搜索树的严格高度控制，所以AVL树的搜索效率很高，但是这是需要付出很大的代价的，要维护父亲指针，和平衡因子。
平衡搜索二叉树（AVL树）
m0_69323023的博客
01-09 2829
AVL树详解
平衡二叉树——AVl树
qq_34434522的博客
10-05 956
从插入节点的父节点开始，逐级向上检查每个祖先节点的平衡因子（Balance Factor, BF），即左子树高度减去右子树高度（BF = height(left) - height(right)），或者相反。AVL树是一种二叉搜索树，意味着每个节点都有一个键值，左子树的所有节点值小于该节点的值，右子树的所有节点值大于该节点的值。AVL树在插入或删除节点时，通过旋转操作来保持树的平衡，以确保所有基本操作的时间复杂度为 O(log n)。节点的高度是其左子树和右子树高度的最大值加一。
高阶数据结构 —— AVL树(平衡搜索树)
lyzzs222的博客
10-14 1344
AVL树的实现，画图+代码，逻辑明明白白的。
高度平衡二叉搜索树（AVL树）
bang___bang_的博客
07-20 950
本文详解AVL树的插入操作，分为2种情况：不旋转和旋转；旋转又细分4个情况:左单璇、右单旋、左右双旋、右左双旋。文章图文并茂，详细讲解实现操作和代码实现。不要从轮子重新造起，要站在巨人的肩膀上！深究原理和实现细节是绝对有帮助的！
Python实现AVL树：自平衡二叉搜索树的构建与维护
11-05
AVL树是一种自平衡二叉搜索树，其主要特点是在每次插入或删除节点后，都会保持树的平衡。树的平衡是通过节点的平衡因子来控制的，平衡因子是该节点左子树的高度与右子树的高度之差。为了确保树的平衡，AVL树要求每个...
二叉搜索树，红黑树，AVL平衡树，B树
05-08
AVL树（Adelson-Velsky and Landis tree）是另一种自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis在1962年提出。AVL树要求每个节点的两个子树的高度差最多为1，以保持高度平衡。因此，AVL树的查询速度比...
avl.rar_avl_平衡树
09-20
5. **查询操作**：由于AVL树保持了较好的平衡，搜索操作的时间复杂度可以达到O(log n)，其中n是树中的节点数。这使得AVL树在需要快速查找的应用中非常有效。 6. **应用**：AVL树常用于数据库索引、文件系统、电话...
基于stm32的万年历.zip
01-09
基于stm32的万年历.zip
基于STM32的全自动节水灌溉系统.zip
01-09
基于STM32的全自动节水灌溉系统.zip
13.000.001.0503.zip
最新发布
01-09
13.000.001.0503.zip
基于JavaWeb的线上数码个性化购物平台的设计与实现源码.zip
01-09
基于JavaWeb的线上数码个性化购物平台的设计与实现源码.zip
SCI复现基于纳什博弈的多微网主体电热双层共享策略研究（Matlab代码实现）
01-09
【SCI复现】基于纳什博弈的多微网主体电热双层共享策略研究（Matlab代码实现）内容概要：本文围绕“基于纳什博弈的多微网主体电热双层共享策略研究”展开，结合Matlab代码实现，复现了SCI级别的科研成果。研究聚焦于多个微网主体之间的能源共享问题，引入纳什博弈理论构建双层优化模型，上层为各微网间的非合作博弈策略，下层为各微网内部电热联合优化调度，实现能源高效利用与经济性目标的平衡。文中详细阐述了模型构建、博弈均衡求解、约束处理及算法实现过程，并通过Matlab编程进行仿真验证，展示了多微网在电热耦合条件下的运行特性和共享效益。; 适合人群：具备一定电力系统、优化理论和博弈论基础知识的研究生、科研人员及从事能源互联网、微电网优化等相关领域的工程师。; 使用场景及目标：① 学习如何将纳什博弈应用于多主体能源系统优化；② 掌握双层优化模型的建模与求解方法；③ 复现SCI论文中的仿真案例，提升科研实践能力；④ 为微电网集群协同调度、能源共享机制设计提供技术参考。; 阅读建议：建议读者结合Matlab代码逐行理解模型实现细节，重点关注博弈均衡的求解过程与双层结构的迭代逻辑，同时可尝试修改参数或扩展模型以适应不同应用场景，深化对多主体协同优化机制的理解。
【​ 物体识别 尺度不变性 图像匹配​】尺度不变关键点的独特图像特征（Matlab代码实现）
01-09
【​ 物体识别 尺度不变性 图像匹配​】尺度不变关键点的独特图像特征（Matlab代码实现）内容概要：本文档围绕“物体识别、尺度不变性、图像匹配”主题，重点介绍了利用尺度不变特征变换（SIFT）算法提取图像中具有尺度不变性的关键点，并结合RANSAC算法实现高分辨率图像的精确匹配与伪造检测。文档提供了完整的Matlab代码实现，详细展示了如何构建独特图像特征以应对旋转、缩放和平移变化，确保在不同条件下仍能稳定识别和匹配图像内容。此外，文档还提到了图像处理技术在科研中的广泛应用，包括图像识别、分割、配准、融合等，突出其在实际项目中的技术价值。; 适合人群：具备一定图像处理基础和Matlab编程经验的科研人员、研究生及从事计算机视觉相关工作的技术人员。; 使用场景及目标：①用于高分辨率图像的匹配与拼接任务；②应用于图像伪造检测与版权保护；③支持物体识别系统中对尺度、角度变化的鲁棒性需求；④为学术研究和工程实践提供可复现的技术方案与代码参考。; 阅读建议：建议读者结合文档提供的Matlab代码进行实践操作，重点关注SIFT特征提取与RANSAC匹配优化的实现细节，同时可拓展学习其他图像处理技术模块以增强综合应用能力。
平衡搜索树详解：从AVL到红黑树
"这篇文档介绍了性能分析中的平衡搜索树，特别是平衡二叉搜索树（AVL树）和红黑树的概念、优势与劣势。作者强调了保持树的平衡对于优化查找效率的重要性，并简述了平衡二叉搜索树的插入操作及其结点结构。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值