树（三）——自平衡二叉树（AVL）

最新推荐文章于 2023-05-30 18:29:27 发布
最新推荐文章于 2023-05-30 18:29:27 发布
阅读量174 收藏
点赞数
文章标签： 数据库 java 数据结构与算法
原文链接：http://www.cnblogs.com/bajdcc/p/4802834.html
版权

简介

自平衡二叉树（AVL）属于二叉平衡树的一类，此类树主要完成一个从键到值的查找过程，即字典（或映射），它维护树高度的方式与其他数据结构不同。

自平衡规则：

  1. AVL树的左、右子树都是AVL树
  2. 左、右子树的高度差不超过1

在数据结构中，最常见的数据间关系的抽象就是集合（Collection）和字典（Dictionary）。

集合就是线性表（元素允许重复），而字典是一种非多键映射关系（键不允许重复）。

对集合而言，一个班中的所有学生构成一个集合，可以是有序的（有序集合）也可以是无序的（无序集合），查找的时间复杂度一般是O(n)，很低。集合的典型就是C#中的List，STL中的vector。集合主要用于存储数据，很少用于查找。如要用于查找，那么可以选择基于有序表的二分查找，相应时间复杂度是O(logn)，而要想从无序表转变为有序表，就是各种排序算法的使命了。

而对字典而言，如同根据一个学生的学号找到他这次考试的成绩一样，主要是用于查找的。这是从键到值的单值映射，键不能重复，值可以重复。根据键找到值是字典的工作。如果是平衡查找树，就为O(logn)，实现一般以红黑树为主（比AVL简单），如Java的TreeMap、STL的map；如果是哈希表，就为O(1)，如Java的HashMap。

源码

由于网上的算法通常是以递归形式出现的，且结点有父指针，更加自由。但是在这里，没有递归，没有父指针，这就意味着，算法的实现难度要更高，算法的维护与调试用了两天时间。

解决递归问题靠栈，解决无父指针问题靠栈，殊途同归。

avltree.h(AVL Tree) AVL树模版

baltree.h(Balance Tree) 平衡树基类

btree.cpp(Binary Tree and Console) main函数

树的建立

在这里，只讲元素的插入， 而对于删除操作，由于其复杂性，暂且不能实现 ，参考网上关于树的旋转等资料，实现了删除操作，但没有进行完整测试。

结点的数据结构为：

template<class T>
struct AVLNode
{
    T data;
    AVLNode *lchild, *rchild;
    int BF; // 平衡因子
};

前面与二叉树一样，BF用于累计高度差，因为查询高度是一个枯燥的递归操作。

这里用到了数学归纳的知识，一开始，树的BF是满足要求的，那么，我们对树的每个操作若可以保证BF满足条件要OK，由于后面的操作建立在前面的操作之上，只要保证了每一步操作的可靠性，那么BF的正确性就是可以保障的。这就要求对于每一个插入和删除操作，要保证类似于数据库那样的ACID特性中的一致性，类比数据库，只要一步操作出错，就算后面的操作是正确的，数据库也没法正常使用了。

创建结点：

template<class T, class N>
N* AVLTree<T, N>::New()
{
    N* newp = BiTree<T, N>::New();
    newp->BF = 0;
    return newp;
}

按数组插入：

template<class T, class N>
AVLTree<T, N>::AVLTree(const vector<T>& s)
{
    if (s.empty()) throw "数组不能为空";
    root = new N;
    root->data = s[0];
    root->BF = 0;
    root->lchild = NULL;
    root->rchild = NULL;
    for (int i = 1; i < s.Length(); i++) Insert(s[i]);
}

树的旋转

1）LL

template<class T, class N>
inline TStatus AVLTree<T, N>::RotateLL(N *&p, N *&parent, N *ancestor)
{
    // 前
    //                                      A(parent,root),BF(2)
    //                                      |
    //                  B(p),BF(1)__________|_____AR
    //                  |
    //        BL(X)_____|_____BR

    // 后
    //                  B(p,root),BF(0)
    //                  |
    //        BL(X)_____|___________________A(parent),BF(0)
    //                                      |
    //                               BR_____|_____AR

    bool descent = !parent->rchild;
    this->RotateRight(p, parent, ancestor);

    parent->BF = p->BF == 1 ? 0 : 1;
    p->BF--;
    N *swap; swap = p; p = parent; parent = swap;
    return (ancestor && descent) ? parent == ancestor->lchild ? T_DECL : T_DECR : T_OK;
}

2）RR

template<class T, class N>
inline TStatus AVLTree<T, N>::RotateRR(N *&p, N *&parent, N *ancestor)
{
    // 前
    //                  A(parent,root),BF(-2)
    //                  |
    //           AL_____|___________________|
    //                                      B(p),BF(-1)
    //                               BL_____|_____BR(X)

    // 后
    //                                      B(p,root),BF(0)
    //                                      |
    //                  A(parent),BF(0)_____|_____BR(X)
    //                  |
    //           AL_____|_____BL

    bool descent = !parent->lchild;
    this->RotateLeft(p, parent, ancestor);

    parent->BF = p->BF == -1 ? 0 : -1;
    p->BF++;
    N *swap; swap = p; p = parent; parent = swap;
    return (ancestor && descent) ? parent == ancestor->lchild ? T_DECL : T_DECR : T_OK;
}

3）LR

template<class T, class N>
inline TStatus AVLTree<T, N>::RotateLR(N *&p, N *&parent, N *ancestor)
{
    //

    // >>>> 情况一

    // 前
    //                                      A(parent,root),BF(2)
    //                                      |
    //                  B(p),BF(-1)_________|_____AR
    //                  |
    //           BL_____|_____C(pc),BF(1)
    //                        |
    //             CL(X)______|______CR

    // 后（减少一层）
    //                                C(pc,root),BF(0)
    //                                |
    //                  B(p),BF(0)____|_____A(parent),BF(-1)
    //                  |                   |
    //           BL_____|_____CL(x)  CR_____|_____AR

    //

    // >>>> 情况二

    // 前
    //                                      A(parent,root),BF(2)
    //                                      |
    //                  B(p),BF(-1)_________|_____AR
    //                  |
    //           BL_____|_____C(pc),BF(-1)
    //                        |
    //                CL______|______CR(X)

    // 后（减少一层）
    //                                C(pc,root),BF(0)
    //                                |
    //                  B(p),BF(1)____|_____A(parent),BF(0)
    //                  |                   |
    //           BL_____|_____CL  CR(x)_____|_____AR

    N *pc = p->rchild;
    this->RotateLeft(pc, p, parent);
    this->RotateRight(pc, parent, ancestor);

    if (pc->BF == 1)
    {
        p->BF = 0;
        parent->BF = -1;
        pc->BF = 0;
    }
    else if (pc->BF == -1)
    {
        p->BF = 1;
        parent->BF = 0;
        pc->BF = 0;
    }
    else
    {
        parent->BF = 0;
        p->BF = 0;
    }
    parent = pc;
    return ancestor ? parent == ancestor->lchild ? T_DECL : T_DECR : T_OK;
}

4）RL

template<class T, class N>
inline TStatus AVLTree<T, N>::RotateRL(N *&p, N *&parent, N *ancestor)
{
    //

    // >>>> 情况一

    // 前
    //                  A(parent,root),BF(-2)
    //                  |
    //           AL_____|___________________B(p),BF(1)
    //                                      |
    //                        C(pc),BF(-1)__|______BR
    //                        |
    //                 CL_____|_____CR(X)

    // 后（减少一层）
    //                                 C(pc,root),BF(0)
    //                                 |
    //                  A(parent),BF(1)|_____B(p),BF(0)
    //                  |                    |
    //           AL_____|_____CL   CR(x)_____|_____BR

    //

    // >>>> 情况二

    // 前
    //                  A(parent,root),BF(-2)
    //                  |
    //           AL_____|___________________B(p),BF(1)
    //                                      |
    //                        C(pc),BF(1)___|______BR
    //                        |
    //              CL(X)_____|_____CR

    // 后（减少一层）
    //                                 C(pc,root),BF(0)
    //                                 |
    //                  A(parent),BF(0)|_____B(p),BF(-1)
    //                  |                    |
    //           AL_____|_____CL(x)   CR_____|_____BR

    N *pc = p->lchild;
    this->RotateRight(pc, p, parent);
    this->RotateLeft(pc, parent, ancestor);

    if (pc->BF == -1)
    {
        parent->BF = 1;
        p->BF = 0;
        pc->BF = 0;
    }
    else if (pc->BF == 1)
    {
        parent->BF = 0;
        p->BF = -1;
        pc->BF = 0;
    }
    else
    {
        parent->BF = 0;
        p->BF = 0;
    }
    parent = pc;
    return ancestor ? parent == ancestor->lchild ? T_DECL : T_DECR : T_OK;
}

5）左旋

template<class T, class N>
void BALTree<T, N>::RotateLeft(N *p, N *parent, N *ancestor)
{
    // 前
    //                  A(parent,root)
    //                  |
    //           AL_____|___________________|
    //                                      B(p)
    //                               BL_____|_____BR(X)

    // 后
    //                                      B(p,root)
    //                                      |
    //                  A(parent)___________|_____BR(X)
    //                  |
    //           AL_____|_____BL

    parent->rchild = p->lchild;
    p->lchild = parent;

    if (ancestor != NULL)
    {
        if (ancestor->lchild == parent) // 修改p的双亲为ancestor
            ancestor->lchild = p;
        else
            ancestor->rchild = p;
    }
    else
    {
        this->root = p;
    }
}

6）右旋

template<class T, class N>
void BALTree<T, N>::RotateRight(N *p, N *parent, N *ancestor)
{
    // 前
    //                                      A(parent,root)
    //                                      |
    //                  B(p)________________|_____AR
    //                  |
    //        BL(X)_____|_____BR

    // 后
    //                  B(p,root)
    //                  |
    //        BL(X)_____|___________________A(parent)
    //                                      |
    //                               BR_____|_____AR

    parent->lchild = p->rchild;
    p->rchild = parent;

    if (ancestor != NULL)
    {
        if (ancestor->lchild == parent) // 修改p的双亲为ancestor
            ancestor->lchild = p;
        else
            ancestor->rchild = p;
    }
    else
    {
        this->root = p;
    }
}

结点的插入

对于AVL，结点的插入是一项复杂的工作。由于插入操作，树原本的平衡被破坏，需要重新调整一次。

基本步骤是：

  1. 二分查找，找到相应的空位置，并插入（若已存在则忽略），同时存储查找路径
  2. 从路径逆着向上找到第一个最小不平衡子树的根结点的父结点，接下来就是对这个子树进行调整
  3. 调整子树，有LL、LR、RL、RR四种情况

1）添加结点

template<class T, class N>
bool BALTree<T, N>::Insert(T data)
{
    N* newp;

    if (this->root == NULL)
    {
        newp = this->New();
        newp->data = data;
        this->root = newp;
        this->HandleRoot();
        return true;
    }

    stack<N*> path; // 存储插入前的查找路径（便于回溯）

    //
    // 插入操作
    N *p = this->root;
    while (true)
    {
        path.push(p);
        if (data < p->data) // 插入值小于根结点，入左子树
        {
            if (p->lchild != NULL)
            {
                p = p->lchild; // 值小于LL，则递归入L
            }
            else
            {
                newp = this->New();
                newp->data = data;
                path.push(newp);
                p->lchild = newp;
                break; // 根结点无左孩子，正好插入
            }
        }
        else if (data > p->data) // 插入值大于根结点，入右子树
        {
            if (p->rchild != NULL)
            {
                p = p->rchild; // 值大于RR，则递归入R
            }
            else
            {
                newp = this->New();
                newp->data = data;
                path.push(newp);
                p->rchild = newp;
                break; // 根结点无右孩子，正好插入
            }
        }
        else // 插入值等于根结点，返回
        {
            return false;
        }
    }

    // 插入完毕

    //

    // 调整插入路径上的结点
    BalanceAfterInsert(path);
    return true;
}

2）插入后的平衡

template<class T, class N>
void BALTree<T, N>::BalanceAfterInsert(stack<N*>& path)
{
    N *child = NULL;  // *child作为*p的孩子结点
    N *p = path.top();
    path.pop();
    N *parent = path.top(); // *parent是*p的父结点
    path.pop();
    N *ancestor;
    while (true)
    {
        ancestor = path.empty() ? NULL : path.top();
        TStatus status = CheckPathAfterInsert(child, p, parent, ancestor);
        switch (status)
        {
            case T_OK:
                return;
            case T_BREAK:
                BalanceInternalAfterInsert(child, p, parent, ancestor);
                return;
            case T_CONTINUE:
                break;
        }

        if (path.empty())
            return;

        child = p;
        p = parent;
        parent = path.top(); // 由path向上回溯
        path.pop();
    }
}

3）检查平衡

template<class T, class N>
TStatus AVLTree<T, N>::CheckPathAfterInsert(N *child, N *p, N *parent, N *ancestor)
{
    if (parent->lchild == p) // p是parent的左孩子，那么parent的BF++
        parent->BF++;  // BF的变化：-1->0->1->2
    else // p是parent的右孩子，那么parent的BF--
        parent->BF--;  // BF的变化：1->0->-1->-2

    if (parent->BF == 2 || parent->BF == -2) // *parent是失衡结点（第一个|BF|>=2）
        return T_BREAK; // 找到最小不平衡子树的根结点

    if (parent->BF == 0) // 在插入新结点后，*parent的左右子树高度相等（BF为0），说明以*parent为根的子树高度未增加
        return T_OK;       // 所以路径中的其余祖先结点无需调整BF

    return T_CONTINUE;
}

4）调整平衡

template<class T, class N>
TStatus AVLTree<T, N>::BalanceInternalAfterInsert(N *child, N *p, N *parent, N *ancestor)
{
    //

    if (parent->BF == 2 && p->lchild == child)    // LL
    {
        RotateLL(p, parent, ancestor);
    }

    //

    else if (parent->BF == -2 && p->rchild == child)    // RR
    {
        RotateRR(p, parent, ancestor);
    }

    //

    else if (parent->BF == 2 && p->rchild == child)    // LR
    {
        RotateLR(p, parent, ancestor);
    }

    //

    else if (parent->BF == -2 && p->lchild == child)    // RL
    {
        RotateRL(p, parent, ancestor);
    }

    //

    return T_OK;
}

调整过程全部是旋转操作

结点的删除

结点的删除比插入要复杂得多。删除某一结点后，可能需要多次调整。

基本步骤是：

  1. 二分查找，找到要删除的结点，并用最近的结点替换掉它，然后删除它，调整BF
  2. 从路径逆着向上找到第一个最小不平衡子树的根结点的父结点，接下来就是对这个子树进行调整
  3. 调整子树，有LL、LR、RL、RR四种情况，如果调整后子树高度下降（即父结点BF改变），那么跳到步骤2

1）定位结点

template<class T, class N>
bool BALTree<T, N>::Delete(T data)
{
    if (this->root == NULL)
    {
        return false;
    }

    stack<N*> path; // 存储删除前的查找路径（便于回溯）

    //
    // 查找操作
    N *p = this->root;
    while (true)
    {
        path.push(p);
        if (data < p->data) // 插入值小于根结点，入左子树
        {
            if (p->lchild != NULL)
            {
                p = p->lchild; // 值小于LL，则递归入L
            }
            else
            {
                return false; // 没找到
            }
        }
        else if (data > p->data) // 插入值大于根结点，入右子树
        {
            if (p->rchild != NULL)
            {
                p = p->rchild; // 值大于RR，则递归入R
            }
            else
            {
                return false; // 没找到
            }
        }
        else // 找到
        {
            break;
        }
    }

    // 定位成功

    //

    // 调整删除路径上的结点
    BalanceAfterDelete(path);
    return true;
}

2）删除结点

template<class T, class N>
void BALTree<T, N>::BalanceAfterDelete(stack<N*>& path)
{
    // 替代结点
    Replace(path);

    if (path.empty())
        return;

    // 删除结点并平衡

    N *p = NULL;
    N *child = NULL;  // *child作为*p的孩子结点
    N *parent = path.top(); // *parent是*p的父结点
    path.pop();
    N *ancestor;
    TStatus status = T_OK;
    while (true)
    {
        ancestor = path.empty() ? NULL : path.top();
        if (status == T_CONTINUE_STATUS)
            status = ancestor ? parent == ancestor->lchild ? T_DECL : T_DECR : T_OK;
        status = CheckPathAfterDelete(child, p, parent, ancestor, status);
        switch (status)
        {
        case T_OK:
            return;
        case T_BREAK:
            status = BalanceInternalAfterDelete(child, p, parent, ancestor);
            if (status == T_OK)
                return;
            break;
        case T_CONTINUE:
            status = T_OK;
            break;
        case T_CONTINUE_STATUS:
            break;
        }

        if (path.empty())
            return;

        child = p;
        p = parent;
        parent = path.top(); // 由path向上回溯
        path.pop();
    }
}

3）替换结点

删除结点前，先将结点与其他结点进行替换，使得对于结点的删除转变为对于叶子结点的删除。

template<class T, class N>
void AVLTree<T, N>::Replace(stack<N*>& path)
{
    N *p = path.top();
    path.pop();
    N *parent = path.empty() ? NULL : path.top();
    if (!p->lchild && !p->rchild) // p为叶子结点，直接删除
    {
        if (!parent) // 根结点
        {
            this->root = NULL;
        }
        else if (parent->lchild == p)
        {
            parent->lchild = NULL;
            parent->BF--;
        }
        else
        {
            parent->rchild = NULL;
            parent->BF++;
        }
    }
    else if (p->lchild && p->rchild) // 双子树，转化为单子树
    {
        // 注意：替换时，BF也要替换
        if (p->lchild->rchild) // 替换左子树最右结点
        {
            vector<N*> new_path;
            new_path.push_back(p->lchild);
            N *lr = p->lchild->rchild;
            while (lr)
            {
                new_path.push_back(lr);
                lr = lr->rchild;
            }
            path.push(new_path.back());
            lr = path.top();
            new_path.pop_back();
            for (vector<N*>::iterator it = new_path.begin(); it != new_path.end(); it++)
            {
                path.push(*it);
            }
            lr->BF = p->BF;
            if (!parent) // 根结点
                this->root = lr;
            else if (parent->lchild == p)
                parent->lchild = lr;
            else
                parent->rchild = lr;
            path.top()->rchild = lr->lchild;
            path.top()->BF++;
            lr->lchild = p->lchild;
            lr->rchild = p->rchild;
        }
        else if (p->rchild->lchild) // 替换右子树最左结点
        {
            vector<N*> new_path;
            new_path.push_back(p->rchild);
            N *rl = p->rchild->lchild;
            while (rl)
            {
                new_path.push_back(rl);
                rl = rl->lchild;
            }
            path.push(new_path.back());
            rl = path.top();
            new_path.pop_back();
            for (vector<N*>::iterator it = new_path.begin(); it != new_path.end(); it++)
            {
                path.push(*it);
            }
            rl->BF = p->BF;
            if (!parent) // 根结点
                this->root = rl;
            else if (parent->lchild == p)
                parent->lchild = rl;
            else
                parent->rchild = rl;
            path.top()->lchild = rl->rchild;
            path.top()->BF--;
            rl->lchild = p->lchild;
            rl->rchild = p->rchild;
        }
        else // 替代孩子
        {
            if (!parent) // 根结点
            {
                if (this->root->BF != -1)
                {
                    this->root = p->lchild;
                    this->root->rchild = p->rchild;
                    this->root->BF = p->BF - 1;
                }
                else
                {
                    this->root = p->rchild;
                    this->root->lchild = p->lchild;
                    this->root->BF = p->BF + 1;
                }
            }
            else if (parent->lchild == p)
            {
                if (parent->BF != -1)
                {
                    parent->lchild = p->lchild;
                    parent->lchild->rchild = p->rchild;
                    parent->lchild->BF = p->BF - 1;
                }
                else
                {
                    parent->lchild = p->rchild;
                    parent->lchild->lchild = p->lchild;
                    parent->lchild->BF = p->BF + 1;
                }
                path.push(parent->lchild);
            }
            else
            {
                if (parent->BF != -1)
                {
                    parent->rchild = p->lchild;
                    parent->rchild->rchild = p->rchild;
                    parent->rchild->BF = p->BF - 1;
                }
                else
                {
                    parent->rchild = p->rchild;
                    parent->rchild->lchild = p->lchild;
                    parent->rchild->BF = p->BF + 1;
                }
                path.push(parent->rchild);
            }
        }
    }
    else if (p->lchild) // 左单子树
    {
        if (!parent) // 根结点
        {
            this->root = p->lchild;
        }
        else
        {
            if (parent->lchild == p)
            {
                parent->lchild = p->lchild;
                parent->BF--;
            }
            else
            {
                parent->rchild = p->lchild;
                parent->BF++;
            }
        }
    }
    else // 右单子树
    {
        if (!parent) // 根结点
        {
            this->root = p->rchild;
        }
        else
        {
            if (parent->lchild == p)
            {
                parent->lchild = p->rchild;
                parent->BF--;
            }
            else
            {
                parent->rchild = p->rchild;
                parent->BF++;
            }
        }
    }
    delete p;
}

4）检查平衡

template<class T, class N>
TStatus AVLTree<T, N>::CheckPathAfterDelete(N *child, N *p, N *parent, N *ancestor, TStatus status)
{
    if (status == T_OK)
    {
        if (p && p->BF == 0)
        {
            if (parent->lchild == p) // p是parent的左孩子，p的BF为0，说明p层数减少一，故parent的BF--
                parent->BF--;
            else // p是parent的右孩子，p的BF为0，说明p层数减少一，故parent的BF++
                parent->BF++;
        }
    }
    else
    {
        if (status == T_DECL) //平衡后，子树高度减少，那么要向上检查平衡性
        {
            parent->BF--;
            return parent->BF == 0 ? T_CONTINUE_STATUS : T_OK;
        }
        else if (status == T_DECR) //平衡后，子树高度减少，那么要向上检查平衡性
        {
            parent->BF++;
            return parent->BF == 0 ? T_CONTINUE_STATUS : T_OK;
        }
    }

    if (parent->BF == 2 || parent->BF == -2) // *parent是失衡结点（第一个|BF|>=2）
        return T_BREAK; // 找到最小不平衡子树的根结点

    if (parent->BF != 0) // 在删除结点后，*parent的左右子树高度差绝对值为1（|BF|为1），说明以*parent为根的子树高度未改变
        return T_OK;       // 所以路径中的其余祖先结点无需调整BF

    return T_CONTINUE;
}

5）调整平衡

template<class T, class N>
TStatus AVLTree<T, N>::BalanceInternalAfterDelete(N *child, N *p, N *parent, N *ancestor)
{
    //

    if (parent->BF == 2 && (!p || parent->rchild == p))    // L
    {
        p = parent->lchild;

        if (p->BF == -1) // LR
        {
            return RotateLR(p, parent, ancestor);
        }
        else // LL
        {
            return RotateLL(p, parent, ancestor);
        }
    }

    //

    else if (parent->BF == -2 && (!p || parent->lchild == p))    // R
    {
        p = parent->rchild;

        if (p->BF == 1) // RL
        {
            return RotateRL(p, parent, ancestor);
        }
        else // RR
        {
            return RotateRR(p, parent, ancestor);
        }
    }

    //
    return T_OK;
}

总结

虽然算法的实现思路很简单，但实际要考虑很多因素，稍微一个小错误都可能导致结果不一致的现象（BF未调整）。然而，在理解AVL上的基础上，理解红黑树就不那么困难了。

相比较AVL的递归算法而言，可以看出，递归算法是具有简洁美的，这是由二叉树的递归性质决定的。

由于AVL操作的复杂性，因而不常用AVL，现在主要使用红黑树（RBT），它们的区别是：

  • AVL讲究整体平衡，因而要求严格、操作复杂 ，子树高度差不大于1
  • RBT追求局部平衡，因而实现较AVL简单，最长路径比上最短路径小于2

转载于:https://www.cnblogs.com/bajdcc/p/4802834.html

R芮R
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
广工数据结构实验——平衡二叉树
07-06
在这个实验中，`平衡二叉树数据结构实验.cpp`很可能是实现平衡二叉树（可能是AVL树或红黑树）的C++源代码。它可能包含了基本的二叉树操作（如插入、删除和查找）以及平衡调整算法的实现。源代码可以帮助我们理解如何...
自平衡二叉树（Self-balancing binary search tree）
cristianoxm的博客
04-09 3160
排序二叉树有以下缺点： 同样的关键字集合有可能导致不同的树结构索引，如下图的右图所示，此时他的搜索性能已经是线性的了，为了解决这种"树一边倒的现象"，自平衡二叉树就被提出来了。平衡二叉树的目的是为了减少二叉查找树层次，提高查找速度。 平衡二叉树 定义：平衡二叉树或为空树,又被称为AVL树（有别于AVL算法）或为如下性质的二叉排序树: （1）左右子树深度之差的绝对值不超过1; （2）左右子树仍...
自平衡二叉树（AVL）及四种旋转方式详解
weixin_49561506的博客
05-30 1543
介绍AVL树的概念，以及AVL树旋转的四种方式
二叉树、自平衡二叉树和多叉树详解
快乐的小三菊的博客
10-21 1751
二叉树、自平衡二叉树和多叉树简单介绍，以及排序方式
自平衡二叉树(AVL树)
lee_nacl的博客
01-30 2079
概述 它是一棵二叉排序树，它的左右两个子树的高度差（平衡因子）的绝对值不超过1，并且左右两棵子树都是一棵平衡二叉树 目的：使得树的高度最低，因为树查找的效率决定树的高度 自平衡二叉树的调整 如果A是一棵平衡二叉树，如果新插入一个元素，会有两个结果 平衡没有被打破，不用调整； 平衡被打破，需要调整 调整规则：根据插入节点与失衡节点的位置关系来划分 LL旋转 插入节点在失衡节点的左子树的左边只需要经过一次左旋即可达到平衡 RR旋转 插入节点在失衡节点的右子树的右边只需要经过一..
自平衡二叉树实现及时间复杂度分析
qq_1015350043的博客
12-10 8971
平衡二叉树的实现我们在遍历二叉树时，先一直往左遍历，于是我们发现，当一棵树的每个节点都只有一个子节点时，他就变成了一个链表，然后链表就说啊：❝年轻人你不要过度消费我，这好吗？这不好。❞所...
C#二叉树与平衡AVL.rar
09-25
在这个“C#二叉树与平衡AVL”压缩包中，我们可以深入探讨二叉排序树（Binary Sort Tree）和其特定类型——平衡二叉树（特别是AVL树）的概念、实现以及它们在C#中的应用。 首先，让我们理解二叉树的基本概念。二叉树...
《剑指Offer》刷题笔记——面试题55-II. 平衡二叉树
12-22
I、自顶向下 II、自底向上 2、代码实现 I、自顶向下 # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution:...
平衡二叉树c++实现
09-26
本文将详细介绍C++实现平衡二叉树——AVL树的过程。AVL树是最早被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL。 1. AVL树的基本概念： - **节点平衡因子**：每个节点...
广工数据结构课程设计大作业-平衡二叉树-Java实现（数据结构期末）
最新发布
11-13
在本项目中，我们主要探讨的是数据结构领域中的一个重要概念——平衡二叉树，并通过Java编程语言进行实现。平衡二叉树是一种特殊的二叉搜索树，它的左右子树的高度差不超过1，从而保证了树的平衡性，进一步提高了...
平衡树详解（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
平衡树【Splay树】学习小记
Tudou_Pika的博客
10-23 2004
平衡树，顾名思义，平衡的搜索二叉树。常见的平衡树都能将树的深度保持在lg⁡n\lg_nlgn​的级别内，防止退化成链。一些平衡树可以通过旋转、分裂、合并等操作完成更加高级的、二叉搜索树做不到的操作。
平衡树详解
一棵油菜花的OI博客
01-11 2512
笔记——树状数据结构篇
【数据结构】图文详解Treap平衡树
qq_49688477的博客
07-27 1610
一、前言 FHQ平衡树是一种树形数据结构，它是对二叉查找树的一种优化方式，但是学习的过程是真的非常的…痛苦。 二、二叉查找树的概念 首先，我们称具有以下3个性质的树为二叉查找树（BST） 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 如图 在这张图中我们可以发现，在二叉查找树中，从根结点开始查找一个点的时间复杂度为logn级别，在我们想对树进行插入查找的时候都非常方便。 但是很遗憾，二叉查找树是有着它的缺陷的
平衡树
yiye2017zhangmu的博客
08-08 2万+
一.概念：    平衡树是二叉搜索树和堆合并构成的数据结构，它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 二.优势    对一棵查找树(search tree)进行查询/新增/删除 等动作, 所花的时间与树的高度h 成比例, 并不与树的容量 n 成比例。如果可以让树维持矮矮胖胖的好身材, 也就是让h维持在O(lg n)左右, 完成上述工作就很...
动图详解平衡树——平衡的二叉搜索树
tunmang5421的博客
04-10 1334
【多动图警告】本文详细介绍了平衡树，加了一些动图和自己的理解
数据结构 —— 图解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 1645
平衡树(Balance Tree，BT) 指的是，任意节点的子树的高度差都小于等于1。常见的符合平衡树的有，B树（多路平衡搜索树）、AVL树（二叉平衡搜索树）等。平衡树可以完成集合的一系列操作, 时间复杂度和空间复杂度相对于“2-3树”要低，在完成集合的一系列操作中始终保持平衡，为大型数据库的组织、索引提供了一条新的途径。 设“2-3 树”的每个结点存放一组与应用问题有关的数据, 且有一个关键字 (>0的整数) 作为标识。关键字的存放规则如下:对于结点X, 设左、中、右子树均不空, 则左子树任一结点的
数据机构实验报告：二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造实验报告.doc
12-18
AVL树是一种自平衡的二叉搜索树，通过旋转操作保持树的平衡性，使得树的高度尽可能小，从而提高搜索效率。我们实践了AVL树的插入和删除操作，了解了如何通过旋转操作对树进行调整以保持平衡。通过对比不同数据规模下...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值