浅析AVL树

最新推荐文章于 2024-04-19 14:01:45 发布
最新推荐文章于 2024-04-19 14:01:45 发布
阅读量254 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kowzb/article/details/115509191
版权
本文详细阐述了AVL树的提出背景，包括平衡因子的定义及其对树结构的影响。深入讲解了二叉平衡树的插入、删除和查找操作，以及关键的旋转算法，包括单旋转和双旋转的实现。通过实例展示了如何确保树的平衡性，以及AVL树在提高搜索效率中的作用。
摘要由CSDN通过智能技术生成

1.为什么提出AVL树

学习完搜索二叉树以后，我们应该想到一个问题，如果我们的搜索二叉树的趋向于单链的形式，类似于：

这里写图片描述

2.二叉平衡树概念和结构

 

为了解决上述问题，所以提出了一个概念，叫做二叉平衡树。

二叉平衡树，相对于二叉搜索树，引入了一个叫做平衡因子的概念。
平衡因子：平衡因子就是右子树的深度-左子树的深度。

二叉平衡树的规则是：每一个节点的平衡因子的绝对值都要小于2。

所以我们需要给一个平衡因子。

二叉平衡树的结构：

template<typename K,typename V>
struct AVLBinaryTreeNode
{
    typedef AVLBinaryTreeNode<K, V> Node;
    AVLBinaryTreeNode(const K& key,const V& value)
        :_left(NULL)
        ,_right(NULL)
        , _parent(NULL)
        ,_key(key)
        , _bf(0)
        , _value(value)
    {}
    Node* _left;
    Node* _right;
    Node* _parent;

    int _bf;    //来保存右子树高度-左子树高度,平衡因子。
    K _key;
    V _value;
};


3.二叉平衡树的平衡化旋转

对于二叉平衡树来说，最重要的就是它的旋转算法，因为他要保证所有节点的平衡因子保持在0，1，-1，所以当平衡因子为2或者-2的时候，我们需要调整，这个时候就引入了旋转这个概念。

例如：

这里写图片描述

比如上面的这个例子，我们可以看出来在这我们的3已经不满足二叉平衡树的条件了，所以在这里我们应该进行旋转。

另外在这里需要知道，对于叶子节点，它的平衡因子都是0。

单旋转

首先我们来看单旋转，单旋转分为两种情况：左单旋和右单旋

这里写图片描述

示例代码：

//左旋
    void _RotateL(Node *parent)
    {
        assert(parent);

        Node* SubR = parent->_right;
        Node* SubRL = SubR->_left;
        parent->_right = SubRL;
        if (SubRL)
            SubRL->_parent = parent;
        Node * ppNode = parent->_parent;            //记录根的父亲    
        SubR->_left = parent;       
        parent->_parent = SubR;
        if (ppNode==NULL)                       //考虑根节点的情况
        {
            _root = SubR;
            SubR->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)           //判断旋转以后的根应该链接在根的父亲的那边
            {
                ppNode->_left = SubR;
            }
            else
            {
                ppNode->_right = SubR;
            }
            SubR->_parent = ppNode;
        }

        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;
        }
        Node* ppNode = parent->_parent;         //记录根节点父亲
        SubL->_right = parent;
        parent->_parent = SubL;
        if (ppNode == NULL)                     //考虑根节点情况
        {
            _root = SubL;
            SubL->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)            //判断旋转以后的根应该链接在根的父亲的那边
            {
                ppNode->_left = SubL;
            }
            else
            {
                ppNode->_right = SubL;
            }
            SubL->_parent = ppNode;
        }


        parent->_bf = SubL->_bf = 0;               //重置平衡因子
    }

双旋转

平衡二叉树有时的旋转是双旋转，双旋转有一个特点，就是他的parent节点和下一个节点平衡因子需要异号。

这里写图片描述

在这，根据sublr的平衡因子不同，分为了3种情况进行插入。接下来，我们对每一种情况进行分析，讲解。

第一种情况：
是sublr的平衡因子为0，这个时候就可以把sublr当作一个要插入的叶子节点来理解，这样subl的平衡因子为1，parentde平衡因子为-2，这样，就构成了双旋转。

这里写图片描述

第二种情况:
sublr的平衡因子为-1，这个时候就是在sublr的左子树进行插入节点操作，这样，subl的平衡因子变为1，parent的平衡因子变为-2。

这里写图片描述

 

第三种情况：
第三种情况所说的就是sublr的平衡因子为1，这个时候插入点是sublr的右树。这样，subl的平衡因子变为1，parent的平衡因子变为-2。

这里写图片描述

上述的就是进行右左双旋时的三种情况，我们可以画一个表格总结下：

这里写图片描述

示例代码：

//左右双旋
    void _RotateLR(Node *parent)
    {
        //进行双旋转的时候通过在这里的旋转以后的根节点的bf进行判断
        Node* SubL = parent->_left;
        Node* SubLR = SubL->_right;
        //计算旋转以后的根节点的bf
        int bf = SubLR->_bf;

        _RotateL(SubL);
        _RotateR(parent);
        //如果bf为0，代表插入点就是这个节点，这个时候所有旋转后的bf皆为0
        if (bf == 0)
        {
            SubL->_bf = parent->_bf = 0;
        }
        //当bf为1时，这个时候相当于是在给bf的右树插入，所以插入以后subL旋转后的右边高度为h，

        else if (bf == 1)
        {
            SubL->_bf = -1;
            parent->_bf = 0;
        }
        //当bf为-1，这时相当于是给bf的左树进行插入
        else
        {
            SubL->_bf = 0;
            parent->_bf = 1;
        }
        SubLR->_bf = 0;
    }

右左双旋转

接下来我们进行另外一种双旋转的分析，右左双旋，有了上面分析的基础，我相信，下面的分析，你一看就能理解，通过单旋转，我们就可以看到，旋转是镜像的

这里写图片描述

 

- subrl的bf==0

这里写图片描述

- subrl的bf==1

这里写图片描述

  • subrl的bf==-1

这里写图片描述

由于右左旋转和上述的左右旋转分析的思路是一样的，所以我也不就在太详细的介绍了。

 

void _RotateRL(Node *parent)
    {
        //双旋转根据插入不同进行调整pf，
        Node* SubR = parent->_right;
        Node* SubRL = SubR->_left;
        //根据最后的根节点的bf进行调整
        int bf = SubRL->_bf;

        _RotateR(SubR);
        _RotateL(parent);
        //当bf为0，代表插入的就是他这个节点，所有的bf都变作0
        if (bf == 0)
        {
            parent->_bf = SubR->_bf = 0;
        }
        //当bf为-1，代表这时是在这个根的左树插入，h-1高度变作h。
        else if (bf == -1)
        {
            parent->_bf = 0;
            SubR->_bf = 1;
        }
        //当bf为1时，代表是在这个旋转后的根的右树插入，h-1的高度作h。
        else
        {
            parent->_bf = -1;
            SubR->_bf = 0;
        }
        SubRL->_bf = 0;


    }

4.二叉平衡树的插入和删除

平衡二叉树的插入算法，和搜索二叉树的插入算法类似，依然是查找到为空的地方，然后进行创建新节点，进行插入，不过这里多了一个parent指针，所以要记得维护，又因为平衡二叉树的特性，所以不能忘了要从插入节点向上检查，确保向上始终为平衡二叉树，否则，需要进行平衡化旋转。

//插入算法
bool Insert(const K& key,const V& value)
    {
        if (_root == NULL)
        {
            _root = new Node(key, value);
            return true;
        }
        Node* parent = NULL;
        Node* cur = _root;
        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->_left = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_right = cur;
            cur->_parent = parent;
        }
        while (parent)
        {
            if (parent->_left == cur)
            {
                parent->_bf--;
            }
            else
            {
                parent->_bf++;
            }
            if (parent->_bf == 0)
            {
                return true;
            }
            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)
                {
                    if (cur->_bf == 1)
                    {
                        _RotateL(parent);
                        return true;
                    }
                    else
                    {
                        _RotateRL(parent);

                        //parent->_bf = _Height(parent->_right) - _Height(parent->_left);
                        //_RotateRL(parent);
                        return true;

                    }
                }
                if (parent->_bf == -2)
                {
                    if (cur->_bf == 1)
                    {
                        _RotateLR(parent);


                        //
                        旋转完以后必须进行重新对parent配置_bf
                        //parent->_bf = _Height(parent->_right) - _Height(parent->_left);
                        return true;

                    }
                    else
                    {
                        _RotateR(parent);
                        return true;

                    }
                }
            }
        }
        return true;
    }

至于删除算法，因为删除的很复杂，在书上看到的是如果在你删除的节点数少与一半的时候，这个时候推荐使用懒惰删除，

规则就是：简单的标记要删除的节点是为已删除。然后在查找等例程里面都人为的忽视标记过的节点。如果标记删除的节点大于总数一半，就进行一次遍历，删除所有标记节点。

5.二叉平衡树的查找

AVL树的

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

查找和搜索二叉树的类似，在这里我就不多说了，直接晒代码。因为在你插入中已经有这方面的逻辑了。

6.总结

AVL树是为了解决二叉搜素树中类似链式的树的时间复杂度太高的问题，如果采用了AVL树，大致时间复杂度都可以变为O（logN），这样就更加高效了。AVL树种最关键的就是它的旋转，分为单旋转和多旋转。AVL树是后续学习红黑树的基础。

#pragma once

#include<iostream>
#include<cstdlib>
#include<cassert>

using namespace std;

template<typename K,typename V>
struct AVLBinaryTreeNode
{
    typedef AVLBinaryTreeNode<K, V> Node;
    AVLBinaryTreeNode(const K& key,const V& value)
        :_left(NULL)
        ,_right(NULL)
        , _parent(NULL)
        ,_key(key)
        , _bf(0)
        , _value(value)
    {}
    Node* _left;
    Node* _right;
    Node* _parent;

    int _bf;    //来保存左右子树的高度差,平衡因子。
    K _key;
    V _value;
};

template<typename K, typename V>
class AVLBinaryTree
{
public:
    typedef AVLBinaryTreeNode<K, V> Node;
public:
    //构造函数
    AVLBinaryTree()
        :_root(NULL)
    {
    }
    //析构函数
    ~AVLBinaryTree()
    {
        _DestoryTree(_root);
    }
    //拷贝构造
    AVLBinaryTree(const AVLBinaryTree<K, V> & a)
    {
        _root = _Copy(_root);
    }
    //现代写法赋值
    AVLBinaryTree<K,V>operator =(const AVLBinaryTree<K,V>& d)
    {
        if (this != &d)
        {
            AVLBinaryTree<K，V> tmp(d);
            std::swap(tmp._root,_root);
        }
            return *this;
    }
    //插入节点
    bool Insert(const K& key,const V& value)
    {
        if (_root == NULL)
        {
            _root = new Node(key, value);
            return true;
        }
        Node* parent = NULL;
        Node* cur = _root;
        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->_left = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_right = cur;
            cur->_parent = parent;
        }
        while (parent)
        {
            if (parent->_left == cur)
            {
                parent->_bf--;
            }
            else
            {
                parent->_bf++;
            }
            if (parent->_bf == 0)
            {
                return true;
            }
            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)
                {
                    if (cur->_bf == 1)
                    {
                        _RotateL(parent);
                        return true;
                    }
                    else
                    {
                        _RotateRL(parent);

                        //parent->_bf = _Height(parent->_right) - _Height(parent->_left);
                        //_RotateRL(parent);
                        return true;

                    }
                }
                if (parent->_bf == -2)
                {
                    if (cur->_bf == 1)
                    {
                        _RotateLR(parent);


                        //
                        旋转完以后必须进行重新对parent配置_bf
                        //parent->_bf = _Height(parent->_right) - _Height(parent->_left);
                        return true;

                    }
                    else
                    {
                        _RotateR(parent);
                        return true;

                    }
                }
            }
        }
        return true;
    }

    //查找节点
    bool Find(const K& key)
    {
        if (_root == NULL)
            return false;
        Node *cur = _root;
        while (cur)
        {
            if (key < cur->_key)
            {
                cur = cur->_left;
            }
            else if (key>cur->_key)
            {
                cur = cur->_right;
            }
            else
            {
                return true;
            }
        }
        return false;
    }
    //判断是否为AVL树
    //bool IsAVLBinaryTree()
    //{
    //  return _IsAVLBinaryTree(_root);
    //}
    bool IsAVLBinaryTree()
    {
        int depth = 0;
        return _IsAVLBinaryTree(_root, depth);

    }
    //中序遍历
    void Inorderprint()
    {
        _Inorderprint(_root); 
        cout << endl;
    }
    //得到高度
    size_t Height() const
    {
        _Height(_root);
    }
protected:
    //拷贝构造二叉树
    Node* _Copy(Node *root)
    {
        Node * NewNode = NULL;
        if (root != NULL)
        {
            NewNode = new Node(root->_value);
            NewNode->_left = _Copy(root->_left);
            NewNode->_right = _Copy(root->_right);
        }
        return NewNode;
    }
    //树的高度
    size_t _Height(Node *root)
    {
        if (root == NULL)
            return 0;
        size_t lheight = _Height(root->_left) + 1;
        size_t rheight = _Height(root->_right) + 1;

        return lheight > rheight ? lheight : rheight;
    }
    //判断二叉树是否为平衡二叉树
    /*bool _IsAVLBinaryTree(Node *root)
    {
        if (root==NULL)
        {
            return true;
        }

        int heightorder = abs((int)(_Height(root->_right) - _Height(root->_left)));

        return ((heightorder<2)
            &&(_IsAVLBinaryTree(root->_left))
            && (_IsAVLBinaryTree(root->_right)));
    }*/
    //判断二叉树是否为平衡二叉树，优化版本
    bool _IsAVLBinaryTree(Node *root,  int & depth)
    {
        //如果为空，往父节点返
        if (root == NULL)
        {
            depth = 0;
            return true;
        }
        //记录左节点和右节点深度
        int left = 0;
        int right = 0;
        //采取传引用的方式，下层递归进行对深度修改以后会影响上一层
        if (_IsAVLBinaryTree(root->_left, left) && _IsAVLBinaryTree(root->_right, right))
        {
            //计算平衡因子
            int pf = right - left;
            //判断平衡因子是否合法
            if (pfIsInvaild(pf))
            {
    //合法就让自身加上子树的深度，然后因为是传引用，所以当递归回到上一层的时候，上层中的right和left就是左右子树的深度
                depth = 1 + (right > left ? right : left);
                return true;
            }
        }
        return false;
    }
    //判断平衡因子是否合法
    bool pfIsInvaild(const int& pf)
    {
        return abs(pf) < 2;
    }
    //中序递归遍历
    void _Inorderprint(Node *root)
    {
        if (root == NULL)
        {
            return;
        }
        _Inorderprint(root->_left);
        cout << root->_key<<" ";
        cout << root->_bf << endl;
        _Inorderprint(root->_right);
    }
    //销毁AVL树
    Node* _DestoryTree(Node*& root)
    {
        if (root != NULL)
        {
            root->_left = _DestoryTree(root->_left);
            root->_right = _DestoryTree(root->_right);
            delete root;
            root = NULL;
        }
        return  root;
    }
    //左旋
    void _RotateL(Node *parent)
    {
        assert(parent);

        Node* SubR = parent->_right;
        Node* SubRL = SubR->_left;
        parent->_right = SubRL;
        if (SubRL)
            SubRL->_parent = parent;
        Node * ppNode = parent->_parent;            //记录根的父亲    
        SubR->_left = parent;       
        parent->_parent = SubR;
        if (ppNode==NULL)                       //考虑根节点的情况
        {
            _root = SubR;
            SubR->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)           //判断旋转以后的根应该链接在根的父亲的那边
            {
                ppNode->_left = SubR;
            }
            else
            {
                ppNode->_right = SubR;
            }
            SubR->_parent = ppNode;
        }

        parent->_bf = SubR->_bf = 0;              //重置平衡因子

    }
    //先左旋后右旋
    //void _RotateLR(Node *parent)
    //{
    //  Node* SubL = parent->_left;
    //  Node* SubLR = SubL->_right;
    //  SubL->_right = SubLR->_left;
    //  if (SubLR->_left)
    //      SubL->_right->_parent = SubL;
    //  SubLR->_left = SubL;
    //  SubL->_parent = SubLR;
    //  parent->_left = SubLR;
    //  SubLR->_parent = parent;
    //  //判断SubLR的左子树是否存在，如果存在，在调整过程当中，需要进行bf的调整
    //  //SubLR的left最后是变成了SubL的left，所以当pf为1时，这个时候调整过去，SubL的pf就是左树比右树大。
    //  if (SubLR->_bf <= 0)
    //      SubL->_bf = 0;
    //  else
    //      SubL->_bf = -1;
    //  parent->_left = SubLR->_right;
    //  if (SubLR->_right)
    //  {
    //      parent->_left->_parent = parent;
    //  }
    //  Node *ppnode = parent->_parent;
    //  SubLR->_right = parent;
    //  parent->_parent = SubLR;
    //  if (ppnode == NULL)
    //  {
    //      _root = SubLR;
    //      SubLR->_parent = NULL;
    //  }
    //  else
    //  {
    //      if (parent == ppnode->_left)
    //      {
    //          ppnode->_left = SubLR;
    //      }
    //      else
    //      {
    //          ppnode->_right = SubLR;
    //      }
    //      SubLR->_parent = ppnode;
    //  }
    //  //同上，这是看SubLR的right是否存在。
    //  if (SubLR->_bf == -1)
    //      parent->_bf = 1;
    //  else
    //      parent->_bf = 0;
    //  SubLR->_bf = 0;
    //}
    void _RotateLR(Node *parent)
    {
        //进行双旋转的时候通过在这里的旋转以后的根节点的bf进行判断
        Node* SubL = parent->_left;
        Node* SubLR = SubL->_right;
        //计算旋转以后的根节点的bf
        int bf = SubLR->_bf;

        _RotateL(SubL);
        _RotateR(parent);
        //如果bf为0，代表插入点就是这个节点，这个时候所有旋转后的bf皆为0
        if (bf == 0)
        {
            SubL->_bf = parent->_bf = 0;
        }
        //当bf为1时，这个时候相当于是在给bf的右树插入，所以插入以后subL旋转后的右边高度为h，

        else if (bf == 1)
        {
            SubL->_bf = -1;
            parent->_bf = 0;
        }
        //当bf为-1，这时相当于是给bf的左树进行插入
        else
        {
            SubL->_bf = 0;
            parent->_bf = 1;
        }
        SubLR->_bf = 0;
    }
    //先右旋后左旋
    //void _RotateRL(Node *parent)
    //{
    //  Node *SubR = parent->_right;
    //  Node *SubRL = SubR->_left;
    //  //右旋
    //  SubR->_left = SubRL->_right;
    //  if (SubRL->_right)
    //      SubR->_right->_parent = SubR;
    //  parent->_right = SubRL;
    //  SubRL->_parent = parent;
    //  SubRL->_right = SubR;
    //  SubR->_parent = SubRL;
    //  if (SubRL->_bf >= 0)
    //      SubR->_bf = 0;
    //  else
    //      SubR->_bf = 1;
    //  //左旋
    //  parent->_right = SubRL->_left;
    //  if (SubRL->_left)
    //      parent->_right->_parent = parent;
    //  Node *ppNode = parent->_parent;
    //  SubRL->_left = parent;
    //  parent->_parent = SubRL;
    //  if (ppNode == NULL)
    //  {
    //      _root = SubRL;
    //      SubRL->_parent = NULL;
    //  }
    //  else
    //  {
    //      if (ppNode->_left == parent)
    //      {
    //          ppNode->_left = SubRL;
    //      }
    //      else
    //      {
    //          ppNode->_right = SubRL;
    //      }
    //      SubRL->_parent = ppNode;
    //  }
    //  if (SubRL->_bf == 1)
    //      parent->_bf = -1;
    //  else
    //      parent->_bf = 0;
    //}
    //右旋
    void _RotateRL(Node *parent)
    {
        //双旋转根据插入不同进行调整pf，
        Node* SubR = parent->_right;
        Node* SubRL = SubR->_left;
        //根据最后的根节点的bf进行调整
        int bf = SubRL->_bf;

        _RotateR(SubR);
        _RotateL(parent);
        //当bf为0，代表插入的就是他这个节点，所有的bf都变作0
        if (bf == 0)
        {
            parent->_bf = SubR->_bf = 0;
        }
        //当bf为-1，代表这时是在这个根的左树插入，h-1高度变作h。
        else if (bf == -1)
        {
            parent->_bf = 0;
            SubR->_bf = 1;
        }
        //当bf为1时，代表是在这个旋转后的根的右树插入，h-1的高度作h。
        else
        {
            parent->_bf = -1;
            SubR->_bf = 0;
        }
        SubRL->_bf = 0;


    }
    //右旋
    void _RotateR(Node *parent)
    {
        Node *SubL = parent->_left;
        Node *SubLR = SubL->_right;
        parent->_left = SubLR;
        if (SubLR)                  
        {
            SubLR->_parent = parent;
        }
        Node* ppNode = parent->_parent;         //记录根节点父亲
        SubL->_right = parent;
        parent->_parent = SubL;
        if (ppNode == NULL)                     //考虑根节点情况
        {
            _root = SubL;
            SubL->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)            //判断旋转以后的根应该链接在根的父亲的那边
            {
                ppNode->_left = SubL;
            }
            else
            {
                ppNode->_right = SubL;
            }
            SubL->_parent = ppNode;
        }


        parent->_bf = SubL->_bf = 0;               //重置平衡因子
    }
protected:
    Node* _root;
};

 

浅析AVL树--AVL树的概念及单旋转
一只巴扎黑的博客
02-19 404
什么是AVL树？ AVL树是一种带有平衡条件的查找二叉树。一般来说，要求一棵AVL树的左右子树高度最多相差1。如下图所示，下面是一个平衡了的AVL树，它的每一个结点的左右子树高度最多相差1。 当我们插入了新结点1之后，这棵就不是平衡二叉树了，因为它的根节点左右子树高度相差2： 我们可以观察到之所以引起了不平衡是因为新插入的结点1破环了根节点的平衡性，使得根节点左右子树相差2。对于上述的情况，我...
AVL树学习
Liam Q的专栏
11-18 3175
1.什么是AVL树           AVL树是带有平衡条件的二叉查找树，是其每个结点的左子树和右子树的高度差最多差1的二叉查找树。如图1，左边的树是AVL树，但右边的不是。 图1 左边的是AVL树，右边的不是 2.AVL树的基本操作          当向一棵AVL树中插入一个结点时，可能破坏AVL树的特性（例如，将6插入图1的AVL树中将会破坏项为8的结点平衡条件）。
avl树
刘佳欢
06-23 431
avl树
AVL树（AVL Tree）
最新发布
m0_65014849的博客
04-19 237
AVL树是一种自平衡的二叉搜索树，它具有以下特性：1. 每个节点的左子树和右子树的高度最多相差1（平衡性）。2. 每个节点存储一个平衡因子（Balance Factor），即其左子树的高度减去右子树的高度。AVL树通过旋转操作来保持树的平衡，包括左旋转、右旋转、左右旋转和右左旋转等操作。在插入和删除节点时，AVL树会根据节点的平衡因子进行调整，以保持树的平衡性。
Java学习笔记(26) AVL Trees
黄瓜菜生长的土地
07-31 1082
浅析 AVL 树，红黑树，B 树，B+ 树
HU1656的博客
04-05 658
一. AVL 树 1.出现的原因 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序，二叉搜索树将有可能退化为单支树，此时查找元素相当于在顺序表中查找元素，效率低下，相当于O(n)。 例如：对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树： 最优情况下，二叉搜索树为完全二叉树。 最差情况下，二叉搜索树退化为单支树。 2.定义 AVL 树是一种二叉平衡搜索树，...
浅析AVL树--AVL树的双旋转
一只巴扎黑的博客
02-19 817
潜析AVL树–AVL树的双旋转 接上篇博文：简析AVL树–AVL树的概念及单旋转 AVL树如何恢复平衡之双旋转 首先假设我们有一颗已经处于平衡的AVL树： 上篇博文已经解决了LL和RR两种情况的平衡恢复解决方案----单旋转。这篇博文来看双旋转情形。这时候我们插入结点7，我们可以发现这时这棵树并没有失去平衡： 但是，如果我们继续插入结点8，这棵树就会再次处于失衡状态： 我们首先可以发现结点9...
平衡树——自平衡二叉树(Balanced Tree - AVL Tree)
UoM_XiaoShuaiShuai的博客
06-10 1635
平衡树——自平衡二叉树(Balanced Tree - AVL Tree)定义(Definition) An AVL tree is a self-balancing binary search tree. It was named after its two inventors: Georgy Adelson-Velsky and Evgenii Landis. Recall that we d
自平衡二叉搜索树（AVL Trees)
Sun.ME的博客
02-23 841
自平衡二叉树、平衡二叉树、二叉树、AVL树
平衡二叉查找树 (AVL Tree)
m0_56321153的博客
08-13 1374
左单旋 treePtr singleLeft(treePtr T){ treePtr tmpPtr; tmpPtr = T; T = T->Left; tmpPtr->Left = T->Right; T->Right = tmpPtr; tmpPtr->Height = max(GetHeight(tmpPtr->Left),GetHeight(tmpPtr->Right))+1; T->Height = max(GetHeight(T-
平衡二叉树（AVL Tree）（左旋、右旋）
Leon_Jinhai_Sun的博客
02-21 1090
AVL Trees (Balanced binary search trees) 平衡二叉树的定义：左右子树深度差绝对值不能超过1。 是什么意思呢？比如左子树的深度是2，右子树的深度只能是1 或者3。 这个时候我们再按顺序插入1、2、3、4、5、6，一定是这样，不会变成一棵“斜树”。 那它的平衡是怎么做到的呢？怎么保证左右子树的深度差不能超过1 呢？ https://www.cs.usfca.edu/~galles/visualization/AVLtree.html 插入1、2、3。 我们注
AVL tree(java详解)
jiaohanhan的博客
05-17 1051
单旋转 双旋转 AVL tree的实现以及源代码
数据结构:AVL树详解(平衡二叉树)
机会是给有准备的人
11-11 4888
假如以 parent 为根的子树不平衡，即 parent 的平衡因子为2或者-2，分以下情况考虑parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR当subR的平衡因子为1时，执行左单旋当subR的平衡因子为-1时，执行右左双旋parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL当subL的平衡因子为-1是，执行右单旋当subL的平衡因子为1时，执行左右双旋。
AVL Trees 学习笔记
星海泛舟记
05-26 4360
AVL Trees 是一种特殊的二叉搜索树，它的作用是通过自我调整，让整棵树保持平衡，从而降低整棵树的高度，以提高查找效率。 本文将首先介绍AVL Trees，然后介绍它的实现方法，性能评估，最后分析题目。 Introduction特点通过自我调整使树趋于平衡，降低树的高度，提高搜索效率本质二叉搜索树变化相比于二叉搜索树，有两个变化，一是每个节点增加了BF属
图文详解AVL树
鱼儿往上游的博客
06-25 725
AVL树（平衡二叉树）详解
【数据结构】AVLTree
m0_61438674的博客
04-24 629
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
erl_tree-avl Trees平衡二叉查找树
u011518176的博客
09-14 446
（AVL—— 发明者为Adel’son-Vel’skii 和 Landis）前面章分析过gb_tree 的插入不是立即平衡的，在查找效率上最坏情况有可能出现O(n), 如何解决这样的问题呢，关键是在减少树的深度，正是基于这个想法，平衡二叉树出现了。平衡二叉查找树，又称 AVL树。 它除了具备二叉查找树的基本特征之外，还具有一个非常重要的特点：它 的左子树和右子树都是平衡二叉树，且左子树和右子树的深度
AVL树基础操作与逻辑功能实现
资源摘要信息:"AVL树的操作实现与概念介绍" 知识点详细说明: 1. AVL树的定义与特性: AVL树是一种自平衡的二叉搜索树，由苏联计算机科学家G.M. Adelson-Velsky和E.M. Landis在1962年提出。AVL树的特点是任何节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值