AVL平衡搜索树

最新推荐文章于 2023-08-23 18:35:08 发布
最新推荐文章于 2023-08-23 18:35:08 发布
阅读量366 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Comedly/article/details/52124059
版权

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


Comedly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
平衡二叉（AVL）树
月守护的博客
12-15 946
在前面的系列文章中，我们讲过了二叉查找树的相关知识和实现（二叉树（一）–概述（附二叉搜索树实现））。在文章的最后，我们总结了二叉查找树的查找时间复杂度： 对于一个节点分布相对均衡的二叉查找树来说，如果节点总数是n，那么搜索节点的时间复杂度是O（logn）,和树的深度是一样的。 但对于极端情况（每次插入数据大小都是增大的，或者减小的），外形上看就只有一半的树，查找时间复杂度就会退化成O（n）的 为了解决二叉查找树查找时间复杂度退化的问题，需要二叉数据的自平衡，也就是本节要讲的平衡二叉树。通过自身的平衡调整
Python之平衡二叉搜索树（AVL树）
夜空下的凝视
04-15 2029
平衡二叉搜索树（Balanced Binary Tree）： 是一种结构平衡的二叉搜索树，即叶节点高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。它能在O(log n)内完成插入、查找和删除操作，最早被发明的平衡二叉搜索树为AVL树。 常见的平衡二叉搜索树有：AVL树、红黑树、Treap、节点大小平衡树。 注意：移动树的节点时，被移动节点及其原新两个位置的父、子节点的指向均需重新指向，...
AVL树及其搜索树
架构设计
03-27 247
首先我们先明确两个关于二叉树的基本概念：深度（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树（平衡二叉搜索树）
langk_的博客
09-03 3289
带你手撕AVL树，左单旋，右单旋，左右双旋，右左双旋
AVL——平衡搜索树
qq_63943454的博客
08-23 605
AVL树是对二叉搜索树的严格高度控制，所以AVL树的搜索效率很高，但是这是需要付出很大的代价的，要维护父亲指针，和平衡因子。
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2630
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
平衡二叉搜索树--AVL详解剖析
qzt__l0ve的博客
07-16 587
平衡二叉搜索树--AVL树关于概念、作用、源码实现等操作。以及对左旋、右旋、左右旋、右左旋的代码讲解和图画讲解
数据结构 --- c语言实现AVL平衡二叉搜索树
weixin_60569662的博客
03-05 952
构建数据类型 #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef struct { int key; //键 char info[20]; //数据类型--->字符串类型 }DATA,*LPDATA; 辅助宏 - - -> 宏函数，获取当前节点p节点的高度 #define HEIGHT(p) ((p==NULL)?-1:(p->hei...
详解AVL树（平衡二叉树）
热门推荐
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
avl.rar_avl_平衡树
09-20
5. **查询操作**：由于AVL树保持了较好的平衡，搜索操作的时间复杂度可以达到O(log n)，其中n是树中的节点数。这使得AVL树在需要快速查找的应用中非常有效。 6. **应用**：AVL树常用于数据库索引、文件系统、电话...
AVLTree.zip_平衡树
09-14
本项目涉及的是AVL树，一种自平衡的二叉搜索树（Binary Search Tree, BST），由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL树。AVL树的特点是任何节点的两个子树的高度最大差别不超过1，这使得AVL...
二叉搜索树，红黑树，AVL平衡树，B树
05-08
AVL树（Adelson-Velsky and Landis tree）是另一种自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis在1962年提出。AVL树要求每个节点的两个子树的高度差最多为1，以保持高度平衡。因此，AVL树的查询速度比...
AVL平衡树及插入操作的C语言实现
06-21
AVL平衡树是一种自平衡的二叉搜索树（Binary Search Tree），由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL树。在AVL树中，任何节点的两个子树的高度最大差别不超过1，这确保了树的平衡性，从而...
AVL___Tree.rar_AVL树_avl_二叉搜索树
09-22
AVL树是一种自平衡二叉搜索树（Binary Search Tree, BST），由Georgy Adelson-Velsky和E.M. Landis在1962年提出，因此得名AVL树。这种数据结构的主要特点是其左右子树的高度差不超过1，从而确保了搜索、插入和删除...
ASP外观专利图像检索平台(源代码+论文).rar
07-21
ASP外观专利图像检索平台(源代码+论文)
C++课程设计：电煤气管理系统【源码+文档】
07-21
C++课程设计：电煤气管理系统【源码+文档】 本程序是一个水电气管理信息系统，能够对高校的水电气费用进行管理, 包括了成员的基本信息，如学号、编号、姓名、成员水电气的用量等。程序的用途包括缴纳水电气费、查询一个同学水电气费用量、查看所有同学的缴费情况、增加学生信息、删除学生信息、退出系统等。在设计时也考虑到学生和教师在用水电气时的不同，学生可以免费使用一定额度的水电气，超过这个额度的以后必须付费，且付费部分水电气费的价格要高于教工的收费标准，该措施的实行是为了鼓励同学们节约资源，以免造成不必要的资源浪费。该软件主要是为了学校的管理人员提供便捷，以更快的完成水电气费用的收缴。该软件本着简洁明了，实用稳定为一体进行设计。 系统将实现以下功能： （1）实现对用户信息的录入； （2）实现水电煤气数据的录入； （3）实现计算并查询用户应缴费用，查询未缴纳费用的名单； （4）实现对人员的删除和添加；
ASP+ACCESS网上动态同学录系统（源代码+论文+系统说明+答辩PPT）.rar
07-21
ASP+ACCESS网上动态同学录系统（源代码+论文+系统说明+答辩PPT）
avaloniassification-mas笔记
最新发布
07-21
avalonia
AVL树：平衡搜索树的优化策略
AVL树是一种自平衡的二叉搜索树，它是在1962年由G.M.Adelson-Velsky和E.M.Landis发明的，用于优化二叉搜索树的性能，特别是减少搜索时间。引入AVL树的主要目的是为了提高二叉搜索树的效率，确保树的高度保持在最优...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值