【C++】AVL树模拟实现

已于 2024-04-22 08:18:15 修改
阅读量462 收藏 2
点赞数 1
分类专栏： C++ 文章标签： c++ avl
于 2022-02-22 17:13:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51064412/article/details/120208080
版权

文章目录

一. 什么是AVL树？

当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1，达到高度平衡，即可降低树的高度，从而减少平均搜索长度。即如果一棵二叉搜索树的任意节点左右子树高度差绝对值都<=1，它就是AVL树。

空树也算AVL树，AVL树一般具有一下性质：

  • 右子树高度 - 左子树高度 之差的绝对值不超过1(-1/0/1)
  • 它的左右子树都是AVL树

在这里插入图片描述

二. 为什么要有AVL树？

AVL树是在搜索树的基础上进行平衡优化后的结果。对一颗搜索树而言，如果数据有序或接近有序搜索树将退化为单支树，这时查询的时间复杂度将变为线性。二AVL树通过旋转操作使得树总是保持平衡，保证查询时高效的时间复杂度。类比AVL树的作用就像快排的三数取中一样解决了快排在数据有序或接近有序时的一趟遍历才能排好一个数的问题，一样是保证了效率。

三. AVL树的实现

1. 基本框架

AVL树主要包括节点类AVLNode和树的本体AVLTree，AVLNode主要存放存储的数据和指向自己亲属的指针，而AVLTree里面主要是实现AVL树的功能：包括插入节点、删除节点等等。

节点类框架

这里我们存储的数据类型是pair，所以要传两个模板参数k和v分别对应键值对中key和value的类型

template<class k,class v>    
struct AVLNode    
{    
  // 构造函数
  AVLNode(const pair<k,v>& kv)    
    :_parent(nullptr)    
    , _left(nullptr)    
    , _right(nullptr)    
    , _kv(kv)    
    , _bf(0)    
  {}    
    
  AVLNode<k,v>* _parent;// 指向父亲节点
  AVLNode<k,v>* _left;  // 指向左孩子
  AVLNode<k,v>* _right; // 指向右孩子
  pair<k,v> _kv;        // 数据域，即键值对
  int _bf;              // 平衡因子：右子树高度减左子树高低
};

树的本体框架

成员变量只有一个就是根节点

template<class k, class v>                                                               
class AVLTree                                                                            
{                                                                                        
  public:                                                                                
    typedef AVLNode<k,v> Node;                                                           
      
  private:      
    Node* _root=nullptr;//根节点      
};

PS:该类只有一个成员变量，没必要特意写构造函数，可以直接在声明_root处赋值为nullptr。这是有必要的，不然会因为后面代码逻辑的原因而造成野指针的访问进而导致结果出问题。

比如我们在插入一个节点时，首先要判断该树是否为空，即_root是否等于nullptr，如果一开始我们没有给根节点初始化的话它就是个非空的随机值，
代码逻辑就会以为不是空树进而导致后面结果出错。
在这里插入图片描述

2. 插入节点

AVL树的插入大体分为两步：

  1. 按照搜索树的方式插入新节点
  2. 调整节点的平衡因子

插入成功返回true，失败返回false。传入的参数为键值对，调用时我们可以make_pair创造一个临时的键值对传入。

2.1 第一步：按搜索树的性质插入节点

分两种情况处理：

  1. 如果是空树的话，直接让_root指向一个动态开辟的节点，作为整棵树的跟节点，插入完成。
  2. 树不空，按搜索树性质寻找插入的位置并记录该位置的父亲，最后开辟节点作为父亲的孩子。
    在这里插入图片描述
bool Insert(const pair<k,v>& kv)
{
  // 插入节点
  // 1、空树的话，就让插入的那个节点作为根
  if(!_root)
  {
    _root=new Node(kv);
    return true;
  }
  // 2、不是空树，就按照搜索树的性质找到插入的位置和它的父亲
  Node* cur=_root;
  Node* parent=nullptr;
  while(cur)
  {
    parent=cur;
    if(cur->_kv.first==kv.first)
    {
      return false;
    }
    else if(cur->_kv.first > kv.first)
    {
      cur=cur->_left;
    }
    else 
    {
      cur=cur->_right;
    }
  }
  // 创建要插入的节点
  Node* newNode=new Node(kv);
  // 更新关系，插入节点
  newNode->_parent=parent;
  if(parent->_kv.first < newNode->_kv.first)
  {
    parent->_right=newNode;
  }
  else 
  {
    parent->_left=newNode;
  }
  // 未完待续....
  return true;
}

补充说明

在这里插入图片描述
因为节点的数据是键值对所以我们传的参数是pair，为了节省空间我们传引用，传入后我们会依照传入的pair完成深拷贝，整个过程不涉及到修改原pair所以我们用const修饰。

这里用const修饰还有另外一个原因，我们在调用传参时通常用make_pair()，这里会生成一个临时的pair对象，临时变量具有常性，想要引用必须加const

下面我们看看这个临时的pair对象从调用时的传入到最后通过深拷贝生成另外一个pair对象所经历的整个过程：
在这里插入图片描述

2.2 穿插补充：树的旋转

旋转的前因后果

根据：平衡因子 = 右子树高度 - 左子树高度 我们可以得到以下结论：

  • 当插入一个节点后，该节点的平衡因子一定是0，如果该节点是父亲的左孩子的话父亲的平衡因子减一，右孩子的话父亲的平衡因子加一。
  • 调整后如果父亲的平衡因子为0，说明父亲的平衡因子原来是1或-1，那么以父亲为根的整棵树高度依然不变，只是把原来低的那边补上了，父亲往上的节点，它们的平衡因子不会受到任何影响。
  • 调整后如果父亲的平衡因子为1或-1，说明父亲原来的平衡因子为0，即原来左右子树的高度相同。现在如果为1是右子树高了，-1是左子树高了。虽然高了但是以父亲为根的整棵树依然平衡（因为左右子树高度差的绝对值并没有大于1），但是整棵树的高度确实是增加了，这时需要继续往上检查，看看祖父及其他祖先有没有平衡。
  • 调整后如果父亲的平衡因子为2或-2,此时已经不平衡了。我们以2为例，为2说明右边高了，那么我们再来看看右孩子的平衡因子（一定是1或-1，不可能是0，为0的话到右孩子哪里就调整结束了，不会在往上调整到它的父亲），如果为1，看孩子这棵树就是右边高了，合起来从父亲的角度来看就是右边的右边高了，该情况通过左单旋可以解决；反之如果为-1，对孩子而言是左边高了，父亲而言是右边的左边高了，这种情况要通过右左双旋来解决。旋转之后整棵树就平衡了且高度不变，这个时候就可以结束了，不用再往上调整。
  • 注意平衡因子不会出现3或-3的情况，因为出现2或-2时就已经通过旋转使其平衡了。

左单旋

插入后parent的平衡因子为2，说明右边高，右孩子的平衡因子为1也是右边高，需要对parent进行左单选，使左边高度增加，右边高度降低。设parent的右子树的根为subR，右子树的左子树的根为subRL

操作：把subRL作为parent的右孩子，parent作为subR的左孩子。

注意：subRL可能为空，parent可能为整棵树的根节点，这时它的父亲为空。

结果：不仅平衡了而且依然满足搜索树的性质。只有parent和subR这两个节点的连接关系发生改变，其他都没变。旋转完成后它们两个的平衡因子变为0

动画演示
在这里插入图片描述

图片演示
在这里插入图片描述
代码实现

void RotateL(Node* parent)
{
  Node* subR=parent->_right;
  Node* subRL=subR->_left;
  // 更新节点之间的连接关系
  parent->_right=subRL;
  if(subRL)// subRL不为空才需要更新它的父亲
  {
    subRL->_parent=parent;
  }
  subR->_left=parent;
  Node* pparent=parent->_parent;
  parent->_parent=subR;
  if(!pparent)// parent为根时的处理
  {
    _root=subR;
    subR->_parent=nullptr;
  }
  else 
  {
    if(pparent->_left==parent)
    {
      pparent->_left=subR;
    }
    else 
    {
      pparent->_right=subR;
    }
    subR->_parent=pparent;
  }
  // 更新平衡因子
  parent->_bf=subR->_bf=0;
}

右单旋

parent的平衡因子为-2，说明parent的左子树高，左孩子的平衡因子为-1，也是左边高。设parent的左子树的根为subL，左子树的右子树的根为subLR

操作：把subLR给parent作为左孩子，然后parent作为subL的右孩子

注意：代码实现时要注意subLR可能为空，并且最后subL要连接上原来parent的父亲，当parent为根节点时它的父亲为nullptr

结果：不仅平衡了而且依然满足搜索树的性质。只有parent和subL的连接关系方式过改变，最终他们的平衡因子都为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* pparent=parent->_parent;
  parent->_parent=subL;
  if(!pparent)
  {
    _root=subL;
    subL->_parent=nullptr;
  }
  else 
  {
    if(pparent->_left==parent)
    {
      pparent->_left=subL;
    }
    else if(pparent->_right==parent)
    {
      pparent->_right=subL;
    }
    subL->_parent=pparent;
  }
  // 更新平衡因子
  parent->_bf=subL->_bf=0;
}

左右双旋 和 右左双旋

两者都差不多，从最终结果看都是把subLR或subRL的两个子树分别分给它的父亲和爷爷，然后自己作为根节点。subLR或subRL的平衡因子决定了最后它父亲和爷爷的平衡因子的值，因为它要把自己的两个子树交给父亲和爷爷，它的平衡因子决定了它两个子树的高度，间接影响了它父亲和它爷爷的高度。

以左右双旋为例，它的情景包括三种，对应插入新节点后subLR的平衡因子可能为 -1、0、1这三种情况。

情况一：插入后subLR的平衡因子变为-1

  • 先左旋subL，把subLR的左孩子分给它父亲作为右孩子
  • 再右旋parent，把subLR的右孩子分给它爷爷作为左孩子
  • 最后subLR变为根，平衡因子为0；插入后subLR的平衡因子为-1，说明他的左子树高（节点插在了左子树），这个高的左子树后面作为它父亲的右子树所以它父亲的平衡因子也为0，而较矮的右子树作为了它爷爷的左孩子，所以最后爷爷的平衡因子变为1
    在这里插入图片描述

情景二：插入后subLR的平衡因子变为1

  • 先左旋subL，把subLR的左孩子作为它父亲的右孩子
  • 再右旋parent，把subLR的右孩子作为它爷爷的左孩子
  • 最后subLR变为根，平衡因子为0，由于插入后subLR的平衡因子为1，说明它的右子树高，这个高的右子树作为爷爷的左孩子使得爷爷的平衡因子也为0，较矮的左子树作为了父亲的右孩子，所以父亲的平衡因子为-1

在这里插入图片描述
情况三：subLR就是新插入的那个节点，它的平衡因子为0

  • 先左旋subL
  • 再右旋parent
  • 最后它们祖孙三个的平衡因子都为0

在这里插入图片描述
PS：右左双旋的操作也大同小异，就不在演示了，只是平衡因子的处理结果相反：如果subRL的平衡因子为1，它爷爷的平衡因子为-1；如果subRL的平衡因子为-1，那么他父亲的平衡因子为1,；如果为0，那么它们祖孙三个也都是0

代码实现
注意：因为里面复用了单旋的接口，经过两次单旋后，祖孙三个节点的平衡因子都在被单旋操作里置为0了，所以最后我们只需特殊处理父亲或爷爷节点的平衡因子就行。

// 左右双旋
void RotateLR(Node* parent)
{
  Node* subL=parent->_left;
  Node* subLR=subL->_right;
  int flag=subLR->_bf;// 记录subLR的平衡因子，最后要依据它来更新其他节点的平衡因子
  // 依次旋转
  RotateL(subL);
  RotateR(parent);
  // 根据subLR平衡因子的值更新不同插入情况下的平衡因子
  if(flag==1)// 说明是在subLR的右子树插入的，那么subLR的左子树变为subL的右子树，subL平衡因子变为-1，subLR和parent的为0
  {
    subL->_bf==-1;
  }
  else if(flag==-1)// 说明是在subLR的左子树插入的，subLR的右子树最后会被分给parent作为左子树，parent的平衡因子变为-1，subL和subLR的平衡因子变为0
  {
    parent->_bf==1;
  }
}

// 右左双旋
void RotateRL(Node* parent)
{
  Node* subR=parent->_right;
  Node* subRL=subR->_left;
  int flag=subRL->_bf;
  // 依次旋转
  RotateR(subR);
  RotateL(parent);
  // 更新平衡因子
  if(flag==1)
  {
    parent->_bf==-1;
  }
  else if(flag==-1) 
  {
    subR->_bf==1;
  }
}

总结

当以parent为根的子树不平衡，也就是parent的平衡因子为2或者-2时，会根据不同的平衡原因来进行不同的旋转操作：

①：parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR，右子树的左子树的根为subRL

  • 当subR的平衡因子为1时，表示的是右子树的右边高，在parent结点进行左单旋操作
  • 当subR的平衡因子为-1时，表示右子树的左边高，此时需要进行右左双旋，也就是以subR结点先进行右单旋，再以parent结点进行左单旋。当subRL的平衡因子为1时，表示在subRL的右边插入新的结点，此时需要更新parent的平衡因子为-1，subR的平衡因子为0；当subRL的平衡因子为-1时，表示在subRL的左边插入新的结点，此时需要更新parent的平衡因子为0，subR的平衡因子为1；当subRL的平衡因子为0时表示 subRL 就是新插入的那个节点，旋转后祖孙三个的平衡因子都为0

②：parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL，左子树的右子树的根为subLR

  • 当subL的平衡因子为-1时，表示左子树的左边高，此时需要进行右单旋
  • 当subL的平衡因子为1时，表示左子树的右边高，此时需要进行左右双旋，也就是以subL结点先进行左单旋，再以parent结点进行右单旋。当subLR的平衡因子为1时，表示在subLR的右边插入新的结点，此时需要更新parent的平衡因子为0，subL的平衡因子为-1；当subLR的平衡因子为-1时，表示在subLR的左边插入新的结点，此时需要更新parent的平衡因子为1，subR的平衡因子为0；当subRL的平衡因子为0时表示 subRL 就是新插入的那个节点，旋转后祖孙三个的平衡因子都为0

2.2 第二步：更新节点的平衡因子

检查树是否平衡，对不平衡的树进行旋转处理，使其平衡并更新节点的平衡因子。下面的代码需要连接到第一步操作的代码的后面：

// 衔接到上面最后的未完待续哪里

// 更新节点的平衡因子
cur=newNode;
parent=cur->_parent;
while(parent)
{
  // 向上更新平衡因子
  if(cur==parent->_left)
  {
    --(parent->_bf);
  }
  else 
  {
    ++(parent->_bf);
  }
  // 检查是否需要调整
  // 0的话就平衡了
  // -1或1的话还要向上更新
  // -2或2的话需要旋转处理
  if(parent->_bf==0)// 平衡因子为0，整棵树高度依然不变，只是补了原来低的那边，依然平衡
  {
    break;
  }
  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);
      }
      else if(cur->_bf==-1)// 右子树的左子树也高  -->  右左双旋
      {
        RotateRL(parent);
      }
    }
    else if(parent->_bf==-2)// 左子树高
    {
      if(cur->_bf==-1)// 左子树的左子树也高  -->  右单旋
      {
        RotateR(parent);
      }
      else if(cur->_bf==1)// 左子树的右子树也高  -->  左右双旋
      {
        RotateLR(parent);
      }
    }
    break;
  }
}

2.3 完整代码

为了方便浏览我们把前面的框架、插入和旋转的代码整合起来

// 树节点的定义
template<class k, class v>
struct AVLNode
{
  // 构造一个节点
  AVLNode(const pair<k,v>& kv)
    :_left(nullptr)
    ,_right(nullptr)
    ,_parent(nullptr)
    ,_kv(kv)
    ,_bf(0)
  {}
  
  AVLNode<k,v>* _left; 
  AVLNode<k,v>* _right; 
  AVLNode<k,v>* _parent;
  pair<k,v> _kv;
  int _bf;
};

// 树本体
template<class k, class v>
class AVLTree
{
  public:
    typedef AVLNode<k,v> Node;
    
    // 插入节点
    bool Insert(const pair<k,v>& kv)
    {
      // 空树的话，就让插入的那个节点作为根
      if(!_root)
      {
        _root=new Node(kv);
        return true;
      }
      // 不是空树，就按照搜索树的性质找到插入的位置和它的父亲
      Node* cur=_root;
      Node* parent=nullptr;
      while(cur)
      {
        parent=cur;
        if(cur->_kv.first==kv.first)
        {
          return false;
        }
        else if(cur->_kv.first > kv.first)
        {
          cur=cur->_left;
        }
        else 
        {
          cur=cur->_right;
        }
      }
      // 创建要插入的节点
      Node* newNode=new Node(kv);
      // 更新关系，插入节点
      newNode->_parent=parent;
      if(parent->_kv.first < newNode->_kv.first)
      {
        parent->_right=newNode;
      }
      else 
      {
        parent->_left=newNode;
      }
      
      cur=newNode;
      parent=cur->_parent;
      while(parent)
      {
        // 向上更新平衡因子
        if(cur==parent->_left)
        {
          --(parent->_bf);
        }
        else 
        {
          ++(parent->_bf);
        }
        // 检查是否需要调整
        // 0的话就平衡了
        // -1或1的话还要向上更新
        // -2或2的话需要旋转处理
        if(parent->_bf==0)// 平衡因子为0，整棵树高度依然不变，只是补了原来低的那边，依然平衡
        {
          break;
        }
        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);
            }
            else if(cur->_bf==-1)// 右子树的左子树也高  -->  右左双旋
            {
              RotateRL(parent);
            }
          }
          else if(parent->_bf==-2)// 左子树高
          {
            if(cur->_bf==-1)// 左子树的左子树也高  -->  右单旋
            {
              RotateR(parent);
            }
            else if(cur->_bf==1)// 左子树的右子树也高  -->  左右双旋
            {
              RotateLR(parent);
            }
          }
          break;
        }
      }
      return true;
    }

  private:
    // 左单旋
    void RotateL(Node* parent)
    {
      Node* subR=parent->_right;
      Node* subRL=subR->_left;
      // 更新节点之间的连接关系
      parent->_right=subRL;
      if(subRL)// subRL不为空才需要更新它的父亲
      {
        subRL->_parent=parent;
      }
      subR->_left=parent;
      Node* pparent=parent->_parent;
      parent->_parent=subR;
      if(!pparent)// parent为根时的处理
      {
        _root=subR;
        subR->_parent=nullptr;
      }
      else 
      {
        if(pparent->_left==parent)
        {
          pparent->_left=subR;
        }
        else 
        {
          pparent->_right=subR;
        }
        subR->_parent=pparent;
      }
      // 更新平衡因子
      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* pparent=parent->_parent;
      parent->_parent=subL;
      if(!pparent)
      {
        _root=subL;
        subL->_parent=nullptr;
      }
      else 
      {
        if(pparent->_left==parent)
        {
          pparent->_left=subL;
        }
        else if(pparent->_right==parent)
        {
          pparent->_right=subL;
        }
        subL->_parent=pparent;
      }
      // 更新平衡因子
      parent->_bf=subL->_bf=0;
    }

    // 左右双旋
    void RotateLR(Node* parent)
    {
      Node* subL=parent->_left;
      Node* subLR=subL->_right;
      int flag=subLR->_bf;// 记录subLR的平衡因子，最后要依据它来更新其他节点的平衡因子
      // 依次旋转
      RotateL(subL);
      RotateR(parent);
      // 根据subLR平衡因子的值更新不同插入情况下的平衡因子
      if(flag==1)// 说明是在subLR的右子树插入的，那么subLR的左子树变为subL的右子树，subL平衡因子变为-1，subLR和parent的为0
      {
        subL->_bf==-1;
      }
      else if(flag==-1)// 说明是在subLR的左子树插入的，subLR的右子树最后会被分给parent作为左子树，parent的平衡因子变为-1，subL和subLR的平衡因子变为0
      {
        parent->_bf==1;
      }
    }

    // 右左双旋
    void RotateRL(Node* parent)
    {
      Node* subR=parent->_right;
      Node* subRL=subR->_left;
      int flag=subRL->_bf;
      // 依次旋转
      RotateR(subR);
      RotateL(parent);
      // 更新平衡因子
      if(flag==1)
      {
        parent->_bf==-1;
      }
      else if(flag==-1) 
      {
        subR->_bf==1;
      }
    }

    Node* _root=nullptr;//根节点
};
Luojj_2020
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++——AVL树
Britney_dark的博客
11-08 1404
如果结果不如你所愿，就在尘埃落定前奋力一搏！
详解c++---AVL树的原理和实现
qq_68695298的博客
06-15 492
用平衡因子来实现avl树
C++数据结构 —— AVL树
weixin_59913110的博客
02-26 542
AVL树是map/set/multimap/multi/set等容器的一种底层结构，其本质就是一颗二叉搜索树。但因为二叉搜索树很容易退化成单支树，所以AVL树便是对二叉搜索树进行升级改造，使其平衡。向二叉搜索树插入节点，保证每个节点的左右子树高度差不超过1(可以包括1)，如果确实达不到这种要求，就需要通过特定的算法来达到这样的要求。一颗AVL树可以是空树，也可以是具有以下性质的二叉搜索树1.每个节点的左右子树都是AVL树2.每个节点的左右子树的高度差不超过1(可以包括1)
AVL树(C++实现)
清欢Allen的技术博客
04-14 1104
我们实现的是KV模型的AVL树,为了方便后续的操作,这里AVL树结点定义为三叉链结构,并且引入平衡因子,方便判断每棵树的平衡情况,并且还需要一个初始化列表将结点成员全部初始化.//三叉链 AVLTreeNode < K , V > * _left;//存储键值对 int _bf;
【数据结构】AVL树——C++实现
Sauron7i的博客
10-01 1024
AVL树特点：**在BST树的基础上，引入了节点“平衡”的概念，任意一个节点的左右子树高度差不超过1。** **为什么要引入平衡这个概念？** 在BST树中，由于插入后就是排序好的，那就会存在这样一种情况：如果插入的元素依次增大，就会导致理想中的二叉树，形成了一个链表，如下图，这种情况会导致增删查的时间复杂度并不是O(logn)，而是O(n)。为了解决这样情况，引入了平衡的概念。
基于最优二叉搜索树的用户登录系统模拟
05-13
AVL，用户登录系统
数据结构C++描述
03-15
11.2.6 AVL搜索树的删除 332 11.3 红－黑树 334 11.3.1 基本概念 334 11.3.2 红－黑树的描述 336 11.3.3 红－黑树的搜索 336 11.3.4 红－黑树的插入 336 11.3.5 红－黑树的删除 339 11.3.6 实现细节的考虑及复杂性...
c/c++二叉树详解，作业，学习参考
12-04
学习数据结构的C++源码，包含AVL树、Treap、多个有序链表合并、二叉查找树、二项堆、红黑树、伸展树、跳表、栈与队列相互模拟以及最小(大)值求解，可做参考学习
C++数据抽象和问题求解（第6版）.[美]Frank M. Carrano(带详细书签).pdf
01-08
19.5 AVL树 577 第20章 图 583 20.1 术语 584 20.2 将图作为ADT 587 20.3 图的遍历 591 20.3.1 深度优先查找 592 20.3.2 广度优先查找 593 20.4 图的应用 595 20.4.1 拓扑排序 595 20.4.2 生成树 598 20.4...
数据结构 C++描述
08-04
11.2.6 AVL搜索树的删除 332 11.3 红－黑树 334 11.3.1 基本概念 334 11.3.2 红－黑树的描述 336 11.3.3 红－黑树的搜索 336 11.3.4 红－黑树的插入 336 11.3.5 红－黑树的删除 339 11.3.6 实现细节的考虑及复杂性...
C++实现AVL树
11-15
C++实现AVL树,有兴趣的可以看看，可能不是很好，仅作为参考
avl树的实现
05-15
数据结构中avl树的实现，包含avl树的插入，删除节点，并以括号表示法输出结果
AVL树与红黑树实现（可视化界面）
03-14
本人实现的 AVL树与红黑树，具有可视化界面，代码清晰。
AVL树 C++ 实现
09-20
平衡二叉树(AVL)的C++实现。 用泛型写的。 IDE为VS2008 好像没别的了~ 就怎么个东西
C++模板实现的AVL树
eskimoer的专栏
11-03 3244
1 AVL树的定义 AVL树是一种自平衡二叉排序树，它的特点是任何一个节点的左子树高度和右子树的高度差在-1,0,1三者之间。AVL树的任何一个子树都是AVL树。 2 AVL树的实现 AVL树本质是一种二叉排序树，所以二叉排序树的任何性质AVL树都具有，但是AVL树稍微复杂的地方就是AVL树必须满足平衡条件，具体跟BST不同的地方主要体现在插入，删除操作。 插入操作：当插入之后可能会出现不
AVL树C++实现（插入，删除，查找，清空，遍历操作）
weixin_34405557的博客
12-13 360
AVL.h文件代码 #pragma once #include<iostream> #include<stack> #include <assert.h> using namespace std; using namespace std; template<class T> struct AVLNode{ T data; AVLNo...
AVL树的c++实现
sysucph的专栏
04-05 184
作为最古老的平衡排序二叉树，avl树算是比较经典了，闲着无聊，也自己实现一下，实现了插入和删除操作。 avl树的特点： 1. 排序二叉树； 2. 左右子树高度差小于等于1； 具体算法流程伪代码随便找一下都会有的，插入也没啥难度，就是判断树高是否发生变化，需要时进行旋转； 删除操作节点，然后转移到删除至多只有一个儿子的节点上，根据树高特点进行旋转； 删除和插入不同的一点，...
AVL树C++实现——高度平衡二叉搜索树
Brant_zero的博客
11-15 714
C++实现，详解AVL树，AVL树的插入(循环实现)以及测试用例。
C++实现 AVL树
sy1227081317的博客
06-04 409
文章目录AVL树简介AVL树的旋转整体代码实现 AVL树简介 AVL树是 “ 搜索 平衡 二叉 树” ，我们知道 AVL树 来自 搜索 树， 我们知道 搜素树可以有效的提高数据的查找效率， 但是如果我们创建搜索树时，数据接近有序，搜索树就会退化成单支，此时我们查找的时间复杂度依然会是O(n)。 因此， 俄罗斯的两位数学家发明了AVL树解决了这个问题，AVL树的命名也是由两位数学家的名字缩写得来。 AVL树的特点是， 树中，任意一个节点的左右子树的高度之差不大于1。 这样就避免了搜索树退化成单支的问题。当A
c++ avl树构建
最新发布
09-09
AVL树是一种自平衡的二叉搜索树，用于高效地插入、删除和查询数据。构建AVL树的基本步骤如下： 1. 首先，创建一个空的AVL树。 2. 从根节点开始，插入第一个元素作为根节点。 3. 对每个新插入的节点，更新它的平衡...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值