平衡二叉树

最新推荐文章于 2022-10-23 13:27:50 发布
最新推荐文章于 2022-10-23 13:27:50 发布
阅读量162 收藏
点赞数
分类专栏： 二叉树 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qiuhongim/article/details/117329614
版权

平衡二叉树（AVL树）

定义

  • 或是空树
  • 或是每个结点深度之差不超过1的二叉排序树
  • 举例如下（结点的平衡因子=左子树深度-右子树深度）：

在这里插入图片描述

旋转（将二叉排序树调整为二叉平衡树）

  • 由于在二叉平衡树中插入或删除结点后，可能使平衡二叉树失去平衡，因此需要对其进行调整。
  • 假设结点a是失去平衡的最小子树的根结点

1. 左单旋转（RR型）

  • 失衡原因：结点的右孩子的右子树插入结点所致
  • 调整策略：以结点的右孩子为轴，逆时针旋转，旋转以后，结点将作为其右孩子的左孩子，结点右孩子原来的左孩子作为结点的右孩子
  • 举例（B、D、E三课子树高度为h）：

在这里插入图片描述

//左单旋转
//结点右孩子的右子树插入结点导致的失衡
//GetHeight函数：获取树的高度
template <typename T>
AvlNode<T>* AvlTree<T>::RR(AvlNode<T>* t)
{
    AvlNode<T>* q = t->right;
    t->right = q->left;
    q->left = t;
    t = q;
    t->height = max(GetHeight(t->left), GetHeight(t->right)) + 1;
    q->height = max(GetHeight(q->left), GetHeight(q->right)) + 1;
    return q;
}

2.右单旋转（LL型）

  • 失衡原因：结点的左孩子的左子树插入结点所致
  • 调整策略：以结点的左孩子为轴，顺时针旋转，旋转以后，结点将作为其左孩子的右孩子，结点左孩子原来的右孩子作为结点的左孩子
  • 举例（B、D、E三课子树高度为h）

在这里插入图片描述

//右单旋转
//结点左孩子的左子树插入结点导致的失衡
//GetHeight函数：获取树的高度
template <typename T>
AvlNode<T>* AvlTree<T>::LL(AvlNode<T>* t)
{
    AvlNode<T>* q = t->left;
    t->left = q->right;
    q->right = t;
    t = q;
    t->height = max(GetHeight(t->left), GetHeight(t->right)) + 1;
    q->height = max(GetHeight(q->left), GetHeight(q->right)) + 1;
    return q;
}

3.先左后右双向旋转（LR型）

  • 失衡原因：结点的左孩子的右子树插入结点所致
  • 调整策略：
    • 第一次，对以结点b为根结点的子树，以结点c为轴，逆时针旋转，将结点c的左子树E作为结点b的右子树，将结点b作为结点c的左子树
    • 第二次，以c为轴，顺时针旋转，c的右子树F作为a的左子树
  • 举例（D、G两颗子树高度为h；E、F两颗子树高度为h-1）

在这里插入图片描述

//先左后右双向旋转
//结点的左孩子的右子树插入结点导致的失衡
template <typename T>
AvlNode<T>* AvlTree<T>::LR(AvlNode<T>* t)
{
    //双旋转可以通过两次单旋转实现
    //对结点的左孩子进行RR旋转，再对结点进行LL旋转
    RR(t->left);
    return LL(t);
}

4.先右后左双向旋转（RL型）

  • 失衡原因：结点的右孩子的左子树插入结点所致
  • 调整策略：
    • 第一次，以结点c为轴，顺时针旋转
    • 第二次，以结点c为轴，逆时针旋转
  • 举例

在这里插入图片描述

//先右后左双向旋转
//结点的右孩子的左子树插入结点导致的失衡
template <typename T>
AvlNode<T>* AvlTree<T>::RL(AvlNode<T>* t)
{
    //双旋转可以通过两次单旋转实现
    //对结点的右孩子进行LL旋转，再对结点进行RR旋转
    LL(t->right);
    return RR(t);
}

获取树的高度

//获取树的高度
template <typename T>
int AvlTree<T>::GetHeight(AvlNode<T>* t)
{
    //空树
    if (t == nullptr)
        return -1;
    //非空树时，返回树的高度
    else
        return t->height;
}

查找最大、最小值结点

//查找最大值结点
template <typename T>
AvlNode<T>* AvlTree<T>::FindMax(AvlNode<T>* t) const
{
    //空树
    if (t == nullptr)
        return nullptr;
    //由于是二叉排序树，结点的右子树为空，直接返回该结点
    if (t->right == nullptr)
        return t;
    //若不符合上面两种情况，继续向结点右子树深入
    return FindMax(t->right);
}

//查找最小值结点
template <typename T>
AvlNode<T>* AvlTree<T>::FindMin(AvlNode<T>* t) const
{
    //空树
    if (t == nullptr)
        return nullptr;
    //由于是二叉排序树，结点的左子树为空，直接返回该结点
    if (t->left == nullptr)
        return t;
    //若不符合上面两种情况，继续向结点的左子树深入
    return FindMin(t->left);
}

插入结点

//插入结点
template <typename T>
void AvlTree<T>::Insert(AvlNode<T>*& t, T x)
{
    if (t == nullptr)//情况一：结点为空
        t = new AvlNode<T>(x);
    else if (x < t->data)//情况二：插入数据小于结点
    {
        Insert(t->left, x);
        //判断平衡
        if (GetHeight(t->left) - GetHeight(t->right) > 1)
        {
            // 分两种情况
            // 插入结点在结点的左孩子的左子树上  左左 LL
            // 插入结点在结点的左孩子的右子树上  左右 LR         
            if (x < t->left->data)//左左
                t = LL(t);
            else                  //左右
                t = LR(t);
        }
    }
    else if (x > t->data)//情况三：插入数据大于结点
    {
        Insert(t->right, x);
        //判断平衡
        if (GetHeight(t->right) - GetHeight(t->left) > 1)
        {
            // 分两种情况
            // 插入结点在结点的右孩子的左子树上  左左 RL
            // 插入结点在结点的右孩子的右子树上  左右 RR  
            if (x > t->right->data)
                t = RR(t);
            else
                t = RL(t);
        }
    }
    else //情况四：插入数据已经存在结点
        ;
    t->height = max(GetHeight(t->left), GetHeight(t->right)) + 1;
}

删除结点

// 删除结点
template <typename T>
bool AvlTree<T>::Delete(AvlNode<T>*& t, T x)
{
    //t为空 要删除的结点未找到  返回false
    if (t == nullptr)
        return false;
    //要删除的结点找到了
    else if (t->data == x)
    {
        //左右子树都非空
        if (t->left != nullptr && t->right != nullptr)
        {//在高度更大的那个子树上进行删除操作

            //左子树高度大，删除左子树中值最大的结点，将其赋给根结点
            if (GetHeight(t->left) > GetHeight(t->right))
            {
                t->data = FindMax(t->left)->data;
                Delete(t->left, t->data);
            }
            else//右子树高度更大，删除右子树中值最小的结点，将其赋给根结点
            {
                t->data = FindMin(t->right)->data;
                Delete(t->right, t->data);
            }
        }
        else
        {//左右子树有一个不为空，直接用需要删除的结点的子结点替换即可
            AvlNode<T>* old = t;
            t = t->left ? t->left : t->right;//t赋值为不空的子结点
            delete old;
        }
    }
    else if (x < t->data)//要删除的结点在左子树上
    {
        //递归删除左子树上的结点
        Delete(t->left, x);
        //判断是否仍然满足平衡条件
        if (GetHeight(t->right) - GetHeight(t->left) > 1)
        {
            if (GetHeight(t->right->left) > GetHeight(t->right->right))
            {
                //RL双旋转
                t = RL(t);
            }
            else
            {//RR单旋转
                t = RR(t);
            }
        }
        else//满足平衡条件 调整高度信息
        {
            t->height = max(GetHeight(t->left), GetHeight(t->right)) + 1;
        }
    }
    else//要删除的结点在右子树上
    {
        //递归删除右子树结点
        Delete(t->right, x);
        //判断平衡情况
        if (GetHeight(t->left) - GetHeight(t->right) > 1)
        {
            if (GetHeight(t->left->right) > GetHeight(t->left->left))
            {
                //LR双旋转
                t = LR(t);
            }
            else
            {
                //LL单旋转
                t = LL(t);
            }
        }
        else//满足平衡性 调整高度
        {
            t->height = max(GetHeight(t->left), GetHeight(t->right)) + 1;
        }
    }

    return true;
}

查找结点

//查找结点
template <typename T>
bool AvlTree<T>::Contains(AvlNode<T>* t, const T x) const
{
    if (t == nullptr)
        return false;
    if (x < t->data)
        return Contains(t->left, x);
    else if (x > t->data)
        return Contains(t->right, x);
    else
        return true;
}

完整代码

#include <iostream>
#include <algorithm>
using namespace std;
#pragma once

//AvlNode
template <typename T>
struct AvlNode
{
    T data;                 //数据域
    int height;             //结点所在高度
    AvlNode<T>* left;       //左孩子指针域    
    AvlNode<T>* right;      //右孩子指针域
    /*结构体初始化*/
    AvlNode<T>(const T value) : data(value), left(nullptr), right(nullptr), height(0) {}
};

//AvlTree
template <class T>
class AvlTree
{
public:
    //默认构造函数
    AvlTree<T>() {}        
    //析构函数
    ~AvlTree<T>() {}        
    /*
    * C++11标准
    * 当使用默认构造函数时，类内成员必须都有类内初始值
    * 当使用其他构造函数时，要将类内成员初始化，否则，即便该类内成员有类内初始值，其值也是未知的
    */
    //二叉树根结点
    AvlNode<T>* root{};//value is set via default member initialization
    //插入结点
    void Insert(AvlNode<T>*& t, T x);
    //删除结点
    bool Delete(AvlNode<T>*& t, T x);
    /*
    * 成员函数后加const表示该成员函数并不修改成员变量，增加程序的可读性、可靠性
    */
    //查找是否存在给定值的结点
    bool Contains(AvlNode<T>* t, const T x) const;
    //中序遍历
    void InorderTraversal(AvlNode<T>* t);
    //前序遍历
    void PreorderTraversal(AvlNode<T>* t);
    //最小值结点
    AvlNode<T>* FindMin(AvlNode<T>* t) const;
    //最大值结点
    AvlNode<T>* FindMax(AvlNode<T>* t) const;
private:
    //求树的高度
    int GetHeight(AvlNode<T>* t);
    //右单旋转
    AvlNode<T>* LL(AvlNode<T>* t);
    //左单旋转
    AvlNode<T>* RR(AvlNode<T>* t);
    //先左后右双旋转
    AvlNode<T>* LR(AvlNode<T>* t);
    //先右后左双旋转
    AvlNode<T>* RL(AvlNode<T>* t);
};

//查找最大值结点
template <typename T>
AvlNode<T>* AvlTree<T>::FindMax(AvlNode<T>* t) const
{
    //空树
    if (t == nullptr)
        return nullptr;
    //由于是二叉排序树，结点的右子树为空，直接返回该结点
    if (t->right == nullptr)
        return t;
    //若不符合上面两种情况，继续向结点右子树深入
    return FindMax(t->right);
}

//查找最小值结点
template <typename T>
AvlNode<T>* AvlTree<T>::FindMin(AvlNode<T>* t) const
{
    //空树
    if (t == nullptr)
        return nullptr;
    //由于是二叉排序树，结点的左子树为空，直接返回该结点
    if (t->left == nullptr)
        return t;
    //若不符合上面两种情况，继续向结点的左子树深入
    return FindMin(t->left);
}

//获取树的高度
template <typename T>
int AvlTree<T>::GetHeight(AvlNode<T>* t)
{
    //空树
    if (t == nullptr)
        return -1;
    //非空树时，返回树的高度
    else
        return t->height;
}

//右单旋转
//结点左孩子的左子树插入结点导致的失衡
template <typename T>
AvlNode<T>* AvlTree<T>::LL(AvlNode<T>* t)
{
    AvlNode<T>* q = t->left;
    t->left = q->right;
    q->right = t;
    t = q;
    t->height = max(GetHeight(t->left), GetHeight(t->right)) + 1;
    q->height = max(GetHeight(q->left), GetHeight(q->right)) + 1;
    return q;
}

//左单旋转
//结点右孩子的右子树插入结点导致的失衡
template <typename T>
AvlNode<T>* AvlTree<T>::RR(AvlNode<T>* t)
{
    AvlNode<T>* q = t->right;
    t->right = q->left;
    q->left = t;
    t = q;
    t->height = max(GetHeight(t->left), GetHeight(t->right)) + 1;
    q->height = max(GetHeight(q->left), GetHeight(q->right)) + 1;
    return q;
}

//先左后右双向旋转
//结点的左孩子的右子树插入结点导致的失衡
template <typename T>
AvlNode<T>* AvlTree<T>::LR(AvlNode<T>* t)
{
    //双旋转可以通过两次单旋转实现
    //对结点的左结点进行RR旋转，再对结点进行LL旋转
    RR(t->left);
    return LL(t);
}

//先右后左双向旋转
//结点的右孩子的左子树插入结点
template <typename T>
AvlNode<T>* AvlTree<T>::RL(AvlNode<T>* t)
{
    //双旋转可以通过两次单旋转实现
    //对结点的右结点进行RR旋转，再对结点进行LL旋转
    LL(t->right);
    return RR(t);
}

//插入结点
template <typename T>
void AvlTree<T>::Insert(AvlNode<T>*& t, T x)
{
    if (t == nullptr)//情况一：结点为空
        t = new AvlNode<T>(x);
    else if (x < t->data)//情况二：插入数据小于结点
    {
        Insert(t->left, x);
        //判断平衡
        if (GetHeight(t->left) - GetHeight(t->right) > 1)
        {
            // 分两种情况
            // 插入结点在结点的左孩子的左子树上  左左 LL
            // 插入结点在结点的左孩子的右子树上  左右 LR         
            if (x < t->left->data)//左左
                t = LL(t);
            else                  //左右
                t = LR(t);
        }
    }
    else if (x > t->data)//情况三：插入数据大于结点
    {
        Insert(t->right, x);
        //判断平衡
        if (GetHeight(t->right) - GetHeight(t->left) > 1)
        {
            // 分两种情况
            // 插入结点在结点的右孩子的左子树上  左左 RL
            // 插入结点在结点的右孩子的右子树上  左右 RR  
            if (x > t->right->data)
                t = RR(t);
            else
                t = RL(t);
        }
    }
    else//情况四：插入数据在二叉树中有结点存在
        ;
    t->height = max(GetHeight(t->left), GetHeight(t->right)) + 1;
}

// 删除结点
template <typename T>
bool AvlTree<T>::Delete(AvlNode<T>*& t, T x)
{
    //t为空 要删除的结点未找到  返回false
    if (t == nullptr)
        return false;
    //要删除的结点找到了
    else if (t->data == x)
    {
        //左右子树都非空
        if (t->left != nullptr && t->right != nullptr)
        {//在高度更大的那个子树上进行删除操作

            //左子树高度大，删除左子树中值最大的结点，将其赋给根结点
            if (GetHeight(t->left) > GetHeight(t->right))
            {
                t->data = FindMax(t->left)->data;
                Delete(t->left, t->data);
            }
            else//右子树高度更大，删除右子树中值最小的结点，将其赋给根结点
            {
                t->data = FindMin(t->right)->data;
                Delete(t->right, t->data);
            }
        }
        else
        {//左右子树有一个不为空，直接用需要删除的结点的子结点替换即可
            AvlNode<T>* old = t;
            t = t->left ? t->left : t->right;//t赋值为不空的子结点
            delete old;
        }
    }
    else if (x < t->data)//要删除的结点在左子树上
    {
        //递归删除左子树上的结点
        Delete(t->left, x);
        //判断是否仍然满足平衡条件
        if (GetHeight(t->right) - GetHeight(t->left) > 1)
        {
            if (GetHeight(t->right->left) > GetHeight(t->right->right))
            {
                //RL双旋转
                t = RL(t);
            }
            else
            {//RR单旋转
                t = RR(t);
            }
        }
        else//满足平衡条件 调整高度信息
        {
            t->height = max(GetHeight(t->left), GetHeight(t->right)) + 1;
        }
    }
    else//要删除的结点在右子树上
    {
        //递归删除右子树结点
        Delete(t->right, x);
        //判断平衡情况
        if (GetHeight(t->left) - GetHeight(t->right) > 1)
        {
            if (GetHeight(t->left->right) > GetHeight(t->left->left))
            {
                //LR双旋转
                t = LR(t);
            }
            else
            {
                //LL单旋转
                t = LL(t);
            }
        }
        else//满足平衡性 调整高度
        {
            t->height = max(GetHeight(t->left), GetHeight(t->right)) + 1;
        }
    }

   return true;
}

//查找结点
template <typename T>
bool AvlTree<T>::Contains(AvlNode<T>* t, const T x) const
{
    if (t == nullptr)
        return false;
    if (x < t->data)
        return Contains(t->left, x);
    else if (x > t->data)
        return Contains(t->right, x);
    else
        return true;
}

//中序遍历
template <typename T>
void AvlTree<T>::InorderTraversal(AvlNode<T>* t)
{
    if (t)
    {
        InorderTraversal(t->left);
        cout << t->data << ' ';
        InorderTraversal(t->right);
    }
}

//前序遍历
template <typename T>
void AvlTree<T>::PreorderTraversal(AvlNode<T>* t)
{
    if (t)
    {
        cout << t->data << ' ';
        PreorderTraversal(t->left);
        PreorderTraversal(t->right);
    }
}

int main()
{
    AvlTree<int> tree;
    int value;
    int tmp;

    cout << "请输入整数建立二叉树(-1结束)：" << endl;
    while (cin >> value)
    {
        if (value == -1)
            break;
        tree.Insert(tree.root, value);
    }

    cout << "中序遍历：";
    tree.InorderTraversal(tree.root);

    cout << "\n前序遍历:";
    tree.PreorderTraversal(tree.root);

    cout << "\n请输入要查找的结点：";
    cin >> tmp;
    if (tree.Contains(tree.root, tmp))
        cout << "查找结点成功！" << endl;
    else
        cout << "值为" << tmp << "的结点不存在!" << endl;
    
    cout << "请输入要删除的结点：";
    cin >> tmp;
    tree.Delete(tree.root, tmp);
    
    cout << "删除后的中序遍历：";
    tree.InorderTraversal(tree.root);

    cout << "\n删除后的前序遍历：";
    tree.PreorderTraversal(tree.root);
    
}

测试结果：

在这里插入图片描述

JauWang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
平衡树详解（Splay）
Wu_while的博客
08-29 1万+
引入 先看例题：（洛谷 P3369 【模板】普通平衡树） 您需要写一种数据结构，来维护一些数，其中需要提供以下操作： 1.插入 xxx 数 2.删除 xxx 数(若有多个相同的数，因只删除一个) 3.查询 xxx 数的排名(排名定义为比当前数小的数的个数 +1+1+1 ) 4.查询排名为 xxx 的数 5.求 xxx 的前驱(前驱定义为小于 xxx，且最大的数) 6.求 xxx 的后继(后继定义为大于 xxx，且最小的数) 显然可以使用BST（二叉搜索树）完成，它的时间复杂度是 O(logn)O(log
平衡树详解
一棵油菜花的OI博客
01-11 2623
笔记——树状数据结构篇
平衡树【Splay树】学习小记
Tudou_Pika的博客
10-23 2012
平衡树，顾名思义，平衡的搜索二叉树。常见的平衡树都能将树的深度保持在lg⁡n\lg_nlgn​的级别内，防止退化成链。一些平衡树可以通过旋转、分裂、合并等操作完成更加高级的、二叉搜索树做不到的操作。
【数据结构】图文详解Treap平衡树
qq_49688477的博客
07-27 1628
一、前言 FHQ平衡树是一种树形数据结构，它是对二叉查找树的一种优化方式，但是学习的过程是真的非常的…痛苦。 二、二叉查找树的概念 首先，我们称具有以下3个性质的树为二叉查找树（BST） 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 如图 在这张图中我们可以发现，在二叉查找树中，从根结点开始查找一个点的时间复杂度为logn级别，在我们想对树进行插入查找的时候都非常方便。 但是很遗憾，二叉查找树是有着它的缺陷的
平衡二叉树AVL操作模板
09-04
平衡二叉树 AVL 操作模板 平衡二叉树 AVL 操作模板是平衡二叉树的一种实现方式，通过 AVL 操作模板，可以对树进行插入、删除、查找等操作，并且保持树的平衡状态。 概念 1. 平衡二叉树：是一种自平衡二叉树，具有...
c++实现平衡二叉树管理的学生管理系统项目
07-02
1. 完成 学生, 课程,选课,成绩 的增删改查 学生ID 学生名 选课名 成绩 001 张三 C++ 60 ...1.采用平衡二叉树的可靠管理，源码规范，文档齐备：80分 2.采用动态数组的可靠管理，源码规范，文档齐备：60分
广工数据结构实验——平衡二叉树
07-06
本实验“广工数据结构实验——平衡二叉树”着重探讨了一种特殊类型的数据结构，即平衡二叉树。平衡二叉树是二叉搜索树（Binary Search Tree, BST）的一个变体，它通过保持树的高度平衡来确保查找、插入和删除操作的...
平衡二叉树时间复杂度计算1
08-08
"平衡二叉树时间复杂度计算1" 在计算机科学中，平衡二叉树是一种特殊的二叉树数据结构，它的时间复杂度计算是非常重要的。下面我们将详细介绍平衡二叉树的时间复杂度计算。 首先，让我们了解什么是平衡二叉树。...
C语言使用递归创建一棵平衡二叉树
10-31
C语言使用递归创建一颗平衡二叉树的源代码文件
C语言平衡二叉树.zip
最新发布
10-27
在IT领域，特别是数据结构与算法的学习中，平衡二叉树是一种重要的数据结构。本文将深入探讨C语言实现平衡二叉树的相关知识点。 首先，我们要理解什么是二叉树。二叉树是每个节点最多有两个子节点的树形数据结构，...
平衡二叉树创建
05-13
平衡二叉树创建，C语言实现，不包含删除
平衡树
yiye2017zhangmu的博客
08-08 2万+
一.概念：    平衡树是二叉搜索树和堆合并构成的数据结构，它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 二.优势    对一棵查找树(search tree)进行查询/新增/删除 等动作, 所花的时间与树的高度h 成比例, 并不与树的容量 n 成比例。如果可以让树维持矮矮胖胖的好身材, 也就是让h维持在O(lg n)左右, 完成上述工作就很...
动图详解平衡树——平衡的二叉搜索树
tunmang5421的博客
04-10 1351
【多动图警告】本文详细介绍了平衡树，加了一些动图和自己的理解
数据结构 —— 图解AVL树(平衡二叉树)
热门推荐
猎人在吃肉
07-28 3万+
文章目录1、AVL树(平衡二叉树)的定义1.1、平衡因子2、AVL树的作用：3、AVL树的基本操作3.1、插入—— 左左型的右旋：3.1.1、右旋的具体步骤：3.1.2、右旋的动画演示：3.1.3、右旋示例：3.2、插入——右右型的左旋：3.2.1、左旋的具体步骤：3.2.2、动画演示：3.2.3、左旋举例：3.3、插入——左右型的左右旋 ( 即先左后右)：3.3.1、左右旋的两次旋转步骤：3.3...
什么是平衡树？
牛牛码特的博客
06-27 1650
平衡树(Balance Tree，BT) 指的是，任意节点的子树的高度差都小于等于1。常见的符合平衡树的有，B树（多路平衡搜索树）、AVL树（二叉平衡搜索树）等。平衡树可以完成集合的一系列操作, 时间复杂度和空间复杂度相对于“2-3树”要低，在完成集合的一系列操作中始终保持平衡，为大型数据库的组织、索引提供了一条新的途径。 设“2-3 树”的每个结点存放一组与应用问题有关的数据, 且有一个关键字 (>0的整数) 作为标识。关键字的存放规则如下:对于结点X, 设左、中、右子树均不空, 则左子树任一结点的
平衡二叉树完全二叉树
09-21
平衡二叉树和完全二叉树是两种不同的二叉树结构。 平衡二叉树是一种特殊的二叉搜索树，或者为空树，或者满足以下条件：它的左子树和右子树的深度之差（平衡因子）的绝对值不超过1，并且左子树和右子树都是一颗平衡...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值