平衡二叉树AVL插入

简介:

平衡二叉树(Balancedbinary tree)是由阿德尔森-维尔斯和兰迪斯(Adelson-Velskiiand Landis)于1962年首先提出的,所以又称为AVL树。

定义:平衡二叉树或为空树,或为如下性质的二叉排序树:

 (1)左右子树深度之差的绝对值不超过1;

 (2)左右子树仍然为平衡二叉树.

        平衡二叉树可以避免排序二叉树深度上的极度恶化,使树的高度维持在O(logn)来提高检索效率。

 

因为插入节点导致整个二叉树失去平衡分成如下的四种情况:

假设由于在二叉排序树上插入节点而失去平衡的最小子数根节点的指针为a(即a是离插入节点最近,且平衡因子绝对值超过1的祖先节点),则失去平衡后进行调整的规律如下:

1.如上图LL单向右旋处理:由于在*a的左子树根节点的左子树上插入节点,*a的平衡因子由1增至2,致使以*a为根节点的子树失去平衡,则需要进行一次向右的顺时针旋转操作。

2.如上图RR单向左旋处理:由于在*a的右子树根节点的右子树上插入节点, *a的平衡因子有-1变为-2,致使以*a为根节点的子树失去平衡,则学要进行一次向左的逆时针旋转操作。

3.如上图LR双向旋转(先左后右)处理:由于在*a的左子树根节点的右子树插入节点,*a的平衡因子有1增至2,致使以*a为根节点的子树失去平衡,则需要进行两次旋转(先左旋后右旋)操作。

4.如上图RL双向旋转(先右后左)处理:由于在*a的右子树根节点的左子树上插入节点,*a的平衡因子由-1变为-2,致使以*a为根节点的子树失去平衡,则需要进行两次旋转(先左旋后右旋)操作。

复制代码
#include<iostream>
#include<cstring>
#include<string>
#include<queue>
#include<map>
#include<cstdio>
#define LH 1 //左高 
#define EH 0 //等高 
#define RH -1 //右高 
using namespace std;

template <typename ElemType>
class BSTNode{
    public:
        ElemType data;//节点的数据 
        int bf;//节点的平衡因子
        BSTNode *child[2];
        BSTNode(){
            child[0] = NULL;
            child[1] = NULL;
        }
};

typedef BSTNode<string> BSTnode, *BSTree;

template <typename ElemType>
class AVL{
    public:
        BSTNode<ElemType> *T;
        void buildT();
        void outT(BSTNode<ElemType> *T);
    private:
        bool insertAVL(BSTNode<ElemType>* &T, ElemType key, bool &taller); 
        void rotateT(BSTNode<ElemType>* &o, int x);//子树的左旋或者右旋
        void leftBalance(BSTNode<ElemType>* &o);
        void rightBalance(BSTNode<ElemType>* &o);
};

template <typename ElemType>
void AVL<ElemType>::rotateT(BSTNode<ElemType>* &o, int x){
    BSTNode<ElemType>* k = o->child[x^1];
    o->child[x^1] = k->child[x];
    k->child[x] = o;
    o = k; 
}

template <typename ElemType>
void AVL<ElemType>::outT(BSTNode<ElemType> *T){
    if(!T) return;
    cout<<T->data<<" ";
    outT(T->child[0]);
    outT(T->child[1]);
}

template <typename ElemType>
void AVL<ElemType>::buildT(){
   T = NULL;
   ElemType key;
   while(cin>>key){
           if(key==0) break;
           bool taller = false;
           insertAVL(T, key, taller);
           outT(T);
           cout<<endl;
   }
}

template <typename ElemType>
bool AVL<ElemType>::insertAVL(BSTNode<ElemType>* &T, ElemType key, bool &taller){
    if(!T){//插入新的节点,taller=true 那么树的高度增加 
        T = new BSTNode<ElemType>();
        T->data = key;
        T->bf = EH;
        taller = true;
    } else {
        if(T->data == key){
            taller = false;
            return false;
        }
        if(T->data > key){//向T的左子树进行搜索并插入 
            if(!insertAVL(T->child[0], key, taller)) return false;
            if(taller){//
                switch(T->bf){
                    case LH://此时左子树的高度高,左子树上又插入了一个节点,失衡,需要进行调整 
                        leftBalance(T);
                        taller = false;//调整之后高度平衡 
                        break; 
                    case EH:
                        T->bf = LH;
                        taller = true;
                        break; 
                    case RH:
                        T->bf = EH;
                        taller = false;                        
                        break;
                }
            }
        } 
        if(T->data < key) {//向T的右子树进行搜索并插入 
            if(!insertAVL(T->child[1], key, taller)) return false;
            switch(T->bf){
                case LH:
                    T->bf = EH;
                    taller = false; 
                    break; 
                case EH:
                    T->bf = RH;
                    taller = true;
                    break; 
                case RH:
                    rightBalance(T);    
                    taller = false;                    
                    break;
            }
        }
    }
    return true;
}

template <typename ElemType>
void AVL<ElemType>::leftBalance(BSTNode<ElemType>* &T){
    BSTNode<ElemType>* lchild = T->child[0];
    switch(lchild->bf){//检查T的左子树的平衡度,并作相应的平衡处理 
        case LH://新节点 插入到 T的左孩子的左子树上,需要对T节点做单旋(右旋)处理 
            T->bf = lchild->bf = EH; 
            rotateT(T, 1);
            break;
        case RH://新节点 插入到 T的左孩子的右子树上,需要做双旋处理  1.对lchild节点进行左旋,2.对T节点进行右旋 
            BSTNode<ElemType>* rdchild = lchild->child[1];
            switch(rdchild->bf){//修改 T 及其左孩子的平衡因子 
                case LH: T->bf = RH; lchild->bf = EH; break;
                case EH: T->bf = lchild->bf = EH; break;//发生这种情况只能是 rdchild无孩子节点
                case RH: T->bf = EH; lchild->bf = LH; break; 
            }
            rdchild->bf = EH; 
            rotateT(T->child[0], 0);//不要写成 rotateT(lc, 0);//这样的话T->lchild不会改变 
            rotateT(T, 1);
            break;
    }
}

template <typename ElemType>
void AVL<ElemType>::rightBalance(BSTNode<ElemType>* &T){
    BSTNode<ElemType>* rchild = T->child[1];
    switch(rchild->bf){//检查T的左子树的平衡度,并作相应的平衡处理 
        case RH://新节点 插入到 T的右孩子的右子树上,需要对T节点做单旋(左旋)处理 
            T->bf = rchild->bf = EH; 
            rotateT(T, 0);
            break;
        case LH://新节点 插入到 T的右孩子的左子树上,需要做双旋处理  1.对rchild节点进行右旋,2.对T节点进行左旋 
            BSTNode<ElemType>* ldchild = rchild->child[0];
            switch(ldchild->bf){//修改 T 及其右孩子的平衡因子 
                case LH: T->bf = EH; rchild->bf = RH; break;
                case EH: T->bf = rchild->bf = EH; break;//发生这种情况只能是 ldchild无孩子节点 
                case RH: T->bf = LH; rchild->bf = EH; break; 
            }
            ldchild->bf = EH; 
            rotateT(T->child[1], 1);
            rotateT(T, 0);
            break;
    }
}

int main(){
    AVL<int> avl;
    avl.buildT();
    avl.outT(avl.T);
    return 0;
} 

/*
 13 24 37 90 53 0
*/









本文转自 小眼儿 博客园博客,原文链接:http://www.cnblogs.com/hujunzheng/p/4665451.html,如需转载请自行联系原作者
目录
相关文章
|
关系型数据库 Linux Apache
|
机器学习/深度学习 存储 计算机视觉
python深度学习图像处理CSV文件分类标签图片到各个文件夹
python深度学习图像处理CSV文件分类标签图片到各个文件夹
576 0
|
6月前
|
机器学习/深度学习 人工智能 算法
通义WebSailor开源,检索性能登顶开源榜单!
通义开源网络智能体WebSailor具备强大推理与检索能力,在复杂场景下表现优异,已登顶开源网络智能体榜单。其创新训练方法大幅提升了模型性能,适用于多领域复杂任务。
747 0
通义WebSailor开源,检索性能登顶开源榜单!
|
12月前
|
缓存 Rust 算法
从混沌到秩序:Python的依赖管理工具分析
Python 的依赖管理工具一直没有标准化,主要原因包括历史发展的随意性、社区的分散性、多样化的使用场景、向后兼容性的挑战、缺乏统一治理以及生态系统的快速变化。依赖管理工具用于处理项目中的依赖关系,确保不同环境下的依赖项一致性,避免软件故障和兼容性问题。常用的 Python 依赖管理工具如 pip、venv、pip-tools、Pipenv、Poetry 等各有优缺点,选择时需根据项目需求权衡。新工具如 uv 和 Pixi 在性能和功能上有所改进,值得考虑。
401 35
|
6月前
|
数据采集 文字识别 供应链
易语言接单平台,易语言接单,易语言软件脚本工具定制
中小企业痛点:2025年仍有43%小微企业存在ERP/CRM定制需求但预算有限(数据来源:中国中小企业协会)
|
10月前
|
机器学习/深度学习 编解码 人工智能
SANA-Sprint:基于连续时间一致性蒸馏的单步扩散模型,0.1秒即可生成图像
Nvidia 提出的 SANA-Sprint 是一种混合蒸馏框架,结合连续时间一致性模型(sCM)与潜在对抗扩散蒸馏(LADD),实现快速高质量文本到图像生成。它支持 1-4 步推理,单步生成 FID 7.59、GenEval 0.74,H100 GPU 上 0.1 秒生成 1024×1024 图像,比 FLUX-Schnell 快 10 倍。通过无训练一致性变换和稳定训练技术,SANA-Sprint 克服传统方法局限,推动实时生成应用。
287 4
SANA-Sprint:基于连续时间一致性蒸馏的单步扩散模型,0.1秒即可生成图像
|
关系型数据库 数据库 PostgreSQL
在docker上部署postgresSQL主从
通过以上步骤,我们完成了在Docker环境中部署PostgreSQL主从复制的基本配置。请注意,实际生产环境中还需考虑安全性增强(如SSL加密)、监控、自动故障切换等高级配置。此外,根据具体的业务需求和规模,可能还需要考虑使用更专业的解决方案或工具,如Patroni、PgBouncer等,来进一步提升数据库集群的稳定性和效率。
985 0
|
监控 算法 项目管理
闲聊项目经理和技术经理的区别
【10月更文挑战第24天】项目经理和技术经理在职责、技能要求、关注重点、管理对象等方面存在明显差异。项目经理负责项目整体规划、资源协调、风险管理及交付;技术经理则侧重技术研发、技术方案制定、团队建设和技术标准维护。项目经理需具备出色的沟通协调、项目管理和风险管理能力,而技术经理则需拥有深厚的技术专长、团队管理能力和持续学习的精神。两者虽有不同,但需紧密合作,共同推动项目成功。
556 4
|
存储 关系型数据库 MySQL
四种数据库对比MySQL、PostgreSQL、ClickHouse、MongoDB——特点、性能、扩展性、安全性、适用场景
四种数据库对比 MySQL、PostgreSQL、ClickHouse、MongoDB——特点、性能、扩展性、安全性、适用场景
|
调度 UED 开发者
【鸿蒙软件开发】UIAbility组件概况、生命周期与启动模式
【鸿蒙软件开发】UIAbility组件概况、生命周期与启动模式
1609 0
【鸿蒙软件开发】UIAbility组件概况、生命周期与启动模式