平衡二叉树

最新推荐文章于 2022-09-01 22:58:17 发布
最新推荐文章于 2022-09-01 22:58:17 发布
阅读量271 收藏
点赞数
分类专栏： 数据结构 算法 文章标签： 二叉树

平衡二叉树的定义 （AVL—— 发明者为Adel'son-Vel'skii 和 Landis）

 

平衡二叉查找树，又称 AVL树。 它除了具备二叉查找树的基本特征之外，还具有一个非常重要的特点：它 的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值（平衡因子 ） 不超过1。 也就是说AVL树每个节点的平衡因子只可能是-1、0和1（左子树高度减去右子树高度）。

 

那么如何是二叉查找树在添加数据的同时保持平衡呢？基本思想就是：当在二叉排序树中插入一个节点时，首先检查是否因插入而破坏了平衡，若 破坏，则找出其中的最小不平衡二叉树，在保持二叉排序树特性的情况下，调整最小不平衡子树中节点之间的关系，以达 到新的平衡。所谓最小不平衡子树 指离插入节点最近且以平衡因子的绝对值大于1的节点作为根的子树。 

 

平衡二叉树的操作

 

1. 查找操作

       平衡二叉树的查找基本与二叉查找树相同。

 

2. 插入操作

       在平衡二叉树中插入结点与二叉查找树最大的不同在于要随时保证插入后整棵二叉树是平衡的。那么调整不平衡树的基本方法就是： 旋转 。 下面我们归纳一下平衡旋转的4中情况

1) 绕某元素左旋转  

                                 80                                    90  

                                 /  \             左旋               /    \

                               60 90          ---- ->         80     120

                                    /  \                               /  \       /

                                  85 120                    60  85 100

                                        /

                                      100     

                               a)  BST树                              b ) AVL树

     分析一下：在插入数据100之前，a图的B ST树只有80节点的平衡因子是-1(左高-右高)，但整棵树还是平衡的。加入100之后，80节点的平衡因子就成为了-2，此时平衡被破坏。需要左旋转成b 图。

     当树中节点X的右孩子的右孩子上插入新元素，且平衡因子从-1变成-2后，就需要绕节点X进行左旋转。

 

2) 绕某元素右旋转  

                                100                                   85

                                 /  \               右旋              /    \

                              85  120         ------ ->     60    100  

                              /  \                                      \      /   \

                            60 90                                 80  90 120

                              \

                              80

                             a) B ST树                                b) AVL树

     当树中节点X的左孩子的左孩子上插入新元素，且平衡因子从1变成2后，就需要绕节点X进行右旋转。

 

3) 绕某元素的左子节点左旋转，接着再绕该元素自己右旋转。 此情况下就是左旋与右旋 的结合，具体操作时可以分 解成这两种操作，只是围绕点不一样而已。

                                                      

                            100                             100                                90

                             /  \             左旋            /  \              右旋           /    \

                          80  120       ------>      90  120        ------>     80   100  

                          / \                                  /                                    /  \      \

                       60 90                            80                              60  85  120

                            /                               / \

                          85                            60 85 

      当树中节点X的左孩子的右孩子上插入新元素，且 平衡因子从1变成2后，就需要 先绕X的左子节点Y左旋转，接着再绕X右旋转


4) 绕某元素的右子节点右旋转，接着再绕该元素自己左旋转。 此情况下就是 右旋与左旋 的结合，具体操作时可以分解 成这两种操作，只是围绕点不一样而已 。

 

                               80                               80                                       85  

                               /   \             右 旋          /  \                 左 旋             /  \     

                            60  100      ------>      60 85            ------->          80 100

                                   /  \                                 \                                   /     /   \       

                                85  120                        100                           60    90 120

                                   \                                   /  \

                                   90                           90  120

       当树中节点X的右孩子的左孩子上插入新元素，且 平衡因子从-1变成-2后，就需要 先绕X的右子节点Y右旋转，接着再绕X左旋转

 

 

平衡二叉树性能分析


平衡二叉树的性能优势：

      很显然，平衡二叉树的优势在于不会出现普通二叉查找树的最差情况。其查找的时间复杂度为O(logN)。

 

平衡二叉树的缺陷：

      (1) 很遗憾的是，为了保证高度平衡，动态插入和删除的代价也随之增加。因此，我们在下一专题中讲讲《红黑树》 这种更加高效的查找结构。

 

      (2) 所有二叉查找树结构的查找代价都与树高是紧密相关的，能否通过减少树高来进一步降低查找代价呢。我们可以通过多路查找树的结构来做到这一点，在后面专题中我们将通过《多路查找树/B-树/B+树 》来介绍。

 

      (3) 在大数据量查找环境下(比如说系统磁盘里的文件目录，数据库中的记录查询 等)，所有的二叉查找树结构(BST、AVL、RBT)都不合适。如此大规模的数据量（几G数据），全部组织成平衡二叉树放在内存中是不可能做到的。那么把这棵树放在磁盘中吧。问题就来了：假如构造的平衡二叉树深度有1W层。那么从根节点出发到叶子节点很可能就需要1W次的硬盘IO读写。大家都知道，硬盘的机械部件读写数据的速度远远赶不上纯电子媒体的内存。 查找效率在IO读写过程中将会付出巨大的代价。在大规模数据查询这样一个实际应用背景下，平衡二叉树的效率就很成问题了


以下为C语言代码

#include <stdio.h>

#include <stdlib.h>
#include <string.h>


typedef int Elemtype;


typedef struct Balanced_Binary_Tree
{
    Elemtype e;
    int bf;
    struct Balanced_Binary_Tree *child[2];
}*AVL;


///------------简单的位操作-------------------
void setbit(char *i,char val,char pos)
{
    if(pos==1)
        (*i)=(*i)|1;
    else
    {
        if(val==1)    (*i)=(*i)|2;
        else    (*i)=(*i)&1;
    }
}
char getbit(char i,char pos)
{
    ///调试时，发现这里能返回2///
//    return (i&pos); 出错的地方
    return (i&pos)&&1;
    /
}
///--------------------------------------------


///-----------生成一个结点---------------------
AVL createnode(Elemtype e)
{
    AVL node=NULL;


    node=(AVL)malloc(sizeof(struct Balanced_Binary_Tree));
    node->e=e;    node->bf=0;
    node->child[0]=node->child[1]=NULL;
    
    return node;
}
///---------------------------------------------


///★★★★★★★★AVL的核心操作★★★★★★★★★★★★
///★★★★★★★★★保持平衡★★★★★★★★★★★★★★


//改变因子函数
void setfactor(AVL f,int button)
{
    char fir=button/10,sec=button%10;
    AVL s=f->child[fir],ss=s->child[sec];
    char choice=ss->bf;
    int a=1,b=0;


    //调试时发现，删除时的特殊情况/
/插入时，不会有这种情况，若button=0,则s->bf=1//
/若button=11，则s->bf=-1；然而删除时，却会出现/
/button=0或者button=11时 s->bf=0!!!!!!!
/那么这种特殊情况，平衡后所得的因子就跟一般的//
/不一样了!!!如下///
    if(button==0 && s->bf==0)    f->bf=1,s->bf=-1;
    else if(button==11 && s->bf==0)    f->bf=-1,s->bf=1;
    ///
    else if(button==0 || button==11)
    {
        f->bf=0;
        s->bf=0;
    }
    else
    {
        /写博客时，发现这里有问题///
    //    if(button==1)    choice=-choice;
        /但是为什么我测试的时候怎么都对?!///
/经再次测试，上边确实错了!!!
/改为下边应该就对了吧///
        if(button==1)    {a^=b,b^=a,a^=b;}
       


        if(choice==-1)    f->bf=a,s->bf=b;
        else if(choice==0)    f->bf=s->bf=0;
        else    f->bf=-b,s->bf=-a;
        
        ss->bf=0;
    }
}
//两节点变换函数
void conversion(AVL *T,char direction)
{
    AVL f=*T,s=f->child[direction];


    f->child[direction]=s->child[!direction];
    s->child[!direction]=f;
    *T=s;
}
//保持平衡函数
void keepbalance(AVL *T,char fir,char sec)
{
    AVL *s=&((*T)->child[fir]);
    int button=fir*10+sec;


    if(button==0 || button==11)
    {
        setfactor((*T),button);
        conversion(T,fir);
    }
    else
    {
        setfactor((*T),button);
        conversion(s,sec);
        conversion(T,fir);
    }
}
///★★★★★★★★★★★★★★★★★★★★★★★★★★


///------------插入时的选向操作-------------------
void selectforInsert(AVL *T,char *info,int direction)
{
    AVL cur=*T;
    char firdirection,secdirection;


    if(direction==0)    (cur->bf)++;
    else    (cur->bf)--;


    if(cur->bf==0)    setbit(info,1,1);
    else if(cur->bf==-1 || cur->bf==1)    setbit(info,direction,2);
    else
    {        
        firdirection=direction;
        secdirection=getbit(*info,2);
        keepbalance(T,firdirection,secdirection);
        setbit(info,1,1);
    }
}
//----------------------------------------------


//*************插入操作************************//
char InsertAVL(AVL *T,Elemtype e)
{                                //可用于查询
    char info;
    
    if(!(*T))
    {
        (*T)=createnode(e);
        return 0;
    }
    else if((*T)->e==e)        return -1;
    else if((*T)->e>e)//左
    {
        info=InsertAVL(&((*T)->child[0]),e);


        if(getbit(info,1))    return info;
        
        selectforInsert(T,&info,0);
    }
    else              //右
    {
        info=InsertAVL(&((*T)->child[1]),e);


        if(getbit(info,1))    return info;


        selectforInsert(T,&info,1);
    }
    return info;
}
//*********************************************//


//-------------删除时的选向操作--------------------
void selectforDelete(AVL *T,char *info,char direction)
{
    AVL cur=(*T);
    char firdirection,secdirection;


    if(direction==0)    (cur->bf)--;
    else    (cur->bf)++;
    
    if(cur->bf==0)    *info=0;
    else if(cur->bf==-1 || cur->bf==1)    *info=1;
    else
    {
        firdirection=!direction;
        ///调试时，发现这里少写了一个等号
//        if(cur->child[firdirection]->bf=1)    secdirection=0;草，真帅气!原来1==a这样写确实有必要!
        if(1==cur->child[firdirection]->bf)    secdirection=0;
        /
        else    secdirection=1;
        keepbalance(T,firdirection,secdirection);


        /
///调试时，发现经过子树平衡操作后，*info不一定都是0，就是那个特殊情况，在setfactor中/
///的那种特殊情况时，这里*info应改为1! 所以代码改如下：//
/
    //    *info=1; 写代码时：这跟插入可不一样啊...该子树平衡了，它父节点的因子比变!
//    *info=0;//因此，这还没完还要是0!! ............啊……这里不一定是0! 
还是那个特殊情况搞的鬼!//
        if(cur->bf==0)    *info=0;
        else    *info=1;
        /
    }
}
//------------------------------------------------


//-------------变向递归--辅助删点-----------------
char find(AVL *gogal,AVL *p)
{
    char info;
    AVL tp=NULL;
    
    if(NULL!=(*p)->child[0])
    {
        info=find(gogal,&((*p)->child[0]));
        if(info!=0)    return info;
        selectforDelete(p,&info,0);
    }
    else
    {
        (*gogal)->e=(*p)->e;
        tp=(*p)->child[1];
        free((*p));
        *p=tp;
        info=0;
    }
    return info;
}
//------------------------------------------------


//**************删除操作*************************//
char DeleteAVL(AVL *T,Elemtype e)
{
    char info;
    AVL tp=NULL;


    if(!(*T))    return -1;//原if(!T)    return -1;于2011年11月29日8:59:15修改
    else if((*T)->e==e)
    {
        if(NULL!=(*T)->child[1])
        {
            info=find(T,&((*T)->child[1]));
            if(info!=0)    return info;
            selectforDelete(T,&info,1);
        }
        else
        {
            //调试时，发现这样写不对!!!///
        //    (*T)=(p=(*T)->child[0])-(free((*T)),0);//Just save a variable! 这里出问题
//    (*T)=p-(free((*T)),0); 可以
//    (*T)=(p=((*T)->child[0]))+(free((*T)),0); 不可以
            tp=((*T)->child[0]);
            free((*T));
            *T=tp;
            //调试时，发现这里漏了给info赋值
            info=0;
            ///
        }
    }
    else if((*T)->e>e)
    {
        info=DeleteAVL(&(*T)->child[0],e);
        if(info!=0)    return info;
        selectforDelete(T,&info,0);
    }
    else
    {
        info=DeleteAVL(&(*T)->child[1],e);
        if(info!=0)    return info;
        selectforDelete(T,&info,1);
    }
    return info;
}
//************************************************//




//*****************JUST FOR TEST************************//
#define MOVE(x)    (x=(x+1)%1000)
AVL queue[1000];


void print(AVL p,int i)
{
    int front,rear,temp,count;


    front=rear=-1; count=temp=0;
    queue[MOVE(rear)]=p; count++;
    
    printf("%d\n",i);
    while(front!=rear)
    {
        p=queue[MOVE(front)];    count--;
        
        
        if(p->child[0])    queue[MOVE(rear)]=p->child[0],temp++;
        if(p->child[1])    queue[MOVE(rear)]=p->child[1],temp++;
        
        printf("%d->%d ",p->e,p->bf);
        if(count==0)
        {
            printf("\n");
            count=temp;
            temp=0;
        }    
    }
    printf("\n");
}
//**************************************************//




int main()
{
    AVL T=NULL;
    int i,nodenum=0;


    freopen("input.txt","w",stdout);
    nodenum=100;
    for(i=0;i<nodenum;i++)
    {
        InsertAVL(&T,i);
    }
    
    print(T,-1);


    for(i=0;i<nodenum-1;i++)
    {
        DeleteAVL(&T,i);
        print(T,i);
    }
    
    return 0;
}
ZMHshare
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
平衡二叉树（AVL树）
zhaohong_bo的专栏
05-18 4910
Mark： https://blog.zhenlanghuo.top/2017/08/22/AVL平衡二叉树的实现/
平衡二叉树(AVL)
u011101683的专栏
10-12 605
平衡二叉树的定义 （AVL—— 发明者为Adel'son-Vel'skii 和 Landis）   平衡二叉查找树，又称 AVL树。 它除了具备二叉查找树的基本特征之外，还具有一个非常重要的特点：它 的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值（平衡因子 ） 不超过1。 也就是说AVL树每个节点的平衡因子只可能是-1、0和1（左子树高度减去右子树高度）。  
【查找结构3】平衡二叉查找树 [AVL]
ccnunlp的专栏
03-08 163
在上一个专题中，我们在谈论二叉查找树的效率的时候。不同结构的二叉查找树，查找效率有很大的不同（单支树结构的查找效率退化成了顺序查找）。如何解决这个问题呢？关键在于如何最大限度的减小树的深度。正是基于这个想法，平衡二叉树出现了。   平衡二叉树的定义 （AVL—— 发明者为Adel'son-Vel'skii 和 Landis）   平衡二叉查找树，又称 ...
AVL树
qq1024734546的博客
08-31 151
4.2AVL树 4.2.1 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果**数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当 于在顺序表中搜索元素，效率低下。**解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之 差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。 一棵AVL树或者是空树，或者是具有以下性质...
AVL二叉平衡树
lankerens
07-31 200
AVL二叉平衡树 说明： AVL二叉平衡树是对二叉排序树的一种调整，当 7 为根节点，6、5、4、3、2 时，所有节点位于左子节点上，导致相当于一条链表， 增删无问题，可是查询的效率甚至还要比链表差[ 因为还需要额外的判断右子树等操作 ] 前提： 是一颗二叉排序树 特点： 它是一颗空树 或者 它的节点的左子树和右子树的高度差绝对值不超过 1 思路： 0. 每添加一次节点，调整一次树 左旋转 1.1 左子树高度 - 右子树高度 > 1 1.2 用当前节点值创建出一个新节点 newNode 1..
平衡二叉树AVL操作模板
09-04
平衡二叉树 AVL 操作模板 平衡二叉树 AVL 操作模板是平衡二叉树的一种实现方式，通过 AVL 操作模板，可以对树进行插入、删除、查找等操作，并且保持树的平衡状态。 概念 1. 平衡二叉树：是一种自平衡二叉树，具有...
c++实现平衡二叉树管理的学生管理系统项目
07-02
1. 完成 学生, 课程,选课,成绩 的增删改查 学生ID 学生名 选课名 成绩 001 张三 C++ 60 ...1.采用平衡二叉树的可靠管理，源码规范，文档齐备：80分 2.采用动态数组的可靠管理，源码规范，文档齐备：60分
平衡二叉树时间复杂度计算1
08-08
"平衡二叉树时间复杂度计算1" 在计算机科学中，平衡二叉树是一种特殊的二叉树数据结构，它的时间复杂度计算是非常重要的。下面我们将详细介绍平衡二叉树的时间复杂度计算。 首先，让我们了解什么是平衡二叉树。...
平衡二叉树(AVL树)
ClimberCoding
05-17 742
参考： 月雲之霄 https://blog.csdn.net/isunbin/article/details/81707606 salt.Zhang https://blog.csdn.net/qq_34930032/article/details/105551355 五分钟学算法 https://mp.weixin.qq.com/s/AweeCscNoLM2kKRA6Q_U8A 平衡二叉树 平衡二叉树首先具备了二叉搜索树的特性，因为二叉搜索树并未对树的高做限制，只要求了左小右大，这就可能在极端情况下，出现
平衡二叉树和AVL
哈喽羊
08-13 3671
1  概述               对于一棵二分搜索树，如果我们的数据是顺序添加到二分搜索树中，它就会退化成一个链表。我们如何解决这个问题呢，我们需要在现有的二分搜索树的基础上添加一些机制，使得我们二分搜索树能维持平衡二叉树这样的一个性质，而AVL就是一种最为经典的平衡二叉树。 什么样的树才是平衡二叉树呢？ 满二叉数：除了叶子节点，其余节点都有左右子树，所以是一棵平衡二叉树 而...
二叉平衡树AVL简介
jakercl的博客
01-27 332
代码实现可见下篇文章，本文主要讲二叉排序树到平衡树的实现过程。 1 二叉平衡树的定义 如果它的左子树不为空，那么左子树上所有节点的值均小于它的根节点的值 如果它的右子树不为空，那么右子树上所有节点的值均大于它的根节点的值 根节点的左子树和右子树均是二叉排序树 平衡二叉树中每个节点的左子树和右子树高度之差的绝对值小于等于1 没有键值相等的节点 平衡二叉树是二叉排序树的进化，是第一个引入平衡概念的二叉树，很好地解决了二叉排序树（二叉查找树）退化为链表的问题；平衡二叉树进行删除和插入一个节点时，
算法小讲堂之平衡二叉树|AVL树（超详细~）
小谢的博客
09-01 924
本文着重于介绍AVL树的基本原理，可能需要二叉树甚至二叉排序树的一些前置知识，非常细致的介绍了四种旋转操作即LL旋、RR旋、LR旋、RL旋，以及结点的查找、插入、删除等操作都做了非常详细的步骤介绍，并且配上了代码，在文末也放上了AVL的应用->实现STL的一个Map容器
AVL树（平衡二叉树）
偷得浮生半日闲
12-13 598
1.平衡二叉树 1.1 简介 AVL树是带有平衡条件的二叉查找树，一般是用平衡因子差值判断是否平衡并通过旋转来实现平衡，左右子树树高不超过1，和红黑树相比，它是严格的平衡二叉树，平衡条件必须满足（所有节点的左右子树高度差不超过1）。不管我们是执行插入还是删除操作，只要不满足上面的条件，就要通过旋转来保持平衡，而旋转是非常耗时的，由此我们可以知道AVL树适合用于插入删除次数比较少，但查找多的情况。 ...
数据结构：二叉树、平衡二叉树、红黑树的原理差异和性能分析
cyq6239075的博客
05-02 1241
树是数据结构中的重中之重，尤其以各类二叉树又是其中的难点，二叉树种类繁多实现各异，我们主要讲常见的二叉树。 1、二叉树 二叉树是指树的度为2的一种树。 满二叉树：在一棵二叉树中，当第i层的节点个数为2^(i-1)时称此层是满的，当树中每一层都是满的时称此树是满二叉树。 完全二叉树：在一棵树中，除最后一层外，若其余层都是满的，并且最后一层或是满的，或是在最右侧缺少连续若干个节点。此时该树称为...
11.1 AVL(平衡二叉树)
weixin_45706249的博客
09-07 157
平衡二叉树(AVL树) 基本介绍： 1.平衡二叉树也叫平衡二叉树搜索树又被称为AVL树，可以保证查询效率较高。 2.具有一下特点：它是一棵空树或它的左右两个子树的高度差绝对值不超过1，并且左右两个子树都是一颗平衡二叉树，平衡为叉树的常用实现方法有红黑树，AVL，替罪羊树，Treap，伸展树等。 求树的高度 //返回左子树高度 public int leftHeight(){ if (this.left == null){ return 0; }
数据结构 — AVL树(平衡二叉树)
阿亮的博客
06-04 2305
AVL树 前面几个博客一直都是针对二叉树的基本操作和概念，今天我们是时候上一个硬菜了，AVL树是有难度的，但是当你掌握你它带给你 的不仅仅是掌握它的算法，他这里还有红黑树的前身，还有它的旋转操作这是一个很经典的算法，所以我们有理由仔仔细细的掌握 它。 好的开始！！！ AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。
看图轻松理解数据结构与算法系列(AVL树)
weixin_34289744的博客
08-09 324
前言 推出一个新系列，《看图轻松理解数据结构和算法》，主要使用图片来描述常见的数据结构和算法，轻松阅读并理解掌握。本系列包括各种堆、各种队列、各种列表、各种树、各种图、各种排序等等几十篇的样子。 AVL树 AVL树，也称平衡二叉搜索树，AVL是其发明者姓名简写。AVL树属于树的一种，而且它也是一棵二叉搜索树，不同的是他通过一定机制能保证二叉搜索树的平衡，平衡的二叉搜索树的查询效率更高。 AVL树特...
算法学习之二叉排序树的平衡化
fnetworkmaster的博客
07-29 683
首先提出问题问什么要让二叉树排序树平衡化比如给出{1,2,3,4,5,6,7}让我们将其构造成排序树，如下图可以看出，此时二叉树变成了数组，而我们为了提高搜索效率的初衷也被打破了为了解决这种极端情况，我们需要对二叉树进行平衡化。...
平衡二叉树完全二叉树
最新发布
09-21
平衡二叉树和完全二叉树是两种不同的二叉树结构。 平衡二叉树是一种特殊的二叉搜索树，或者为空树，或者满足以下条件：它的左子树和右子树的深度之差（平衡因子）的绝对值不超过1，并且左子树和右子树都是一颗平衡...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值