AVL数的建立

最新推荐文章于 2022-12-17 22:28:18 发布
原创 最新推荐文章于 2022-12-17 22:28:18 发布 · 468 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python

AVL树是一种自平衡二叉搜索树，确保每个节点的左右子树高度差不超过1。当节点高度差达到2时，需要进行自平衡调整。删除操作分为三种情况：删除叶子节点、只有一个子树的节点和拥有两个子树的节点。删除后需更新平衡因子并进行必要的平衡旋转。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

AVL数是一棵自平衡的二叉搜索树。数的每一个节点的左右子树高度差绝对值不能超过1.

如果某一个节点的左右子树的高度差绝对值等于2时，则二叉树需要自平衡操作：

 

 

 

class BiTreeNode():         # 定义二叉树型节点
    def __init__(self,val):
        self.data = val
        self.lchild = None
        self.rchild = None
        self.parent = None
        self.bf = None

class AVLTree():            # 定义AVL数对象
    def __init__(self):
        self.root = None

    def node_depth(self,node):      # 计算以节点node为根的数高度
        if not node:
            return 0
        if not node.lchild and not node.rchild:
            return 1
        else:
            ml = self.node_depth(node.lchild)+1
            mr = self.node_depth(node.rchild)+1
        return max(ml,mr)

    def bf_update(self,node):       # 更新节点的balance factor
        flag_change2zero = 0
        if not node:
            return 0, flag_change2zero
        else:
            ml = self.node_depth(node.lchild)
            mr = self.node_depth(node.rchild)
            bf = ml - mr
        if node.bf and bf == 0:     # 如果该节点的bf变化为0，则该节点的父节点的bf值将不受影响
            flag_change2zero = 1
        return bf,flag_change2zero

    def rotate_left(self,node_f,node_s):    # 左旋
        if node_f.parent:       # 判断旋转之前的node_f节点是否有父节点，有的话需要将旋转后的节点与父节点相连
            node_gf = node_f.parent
        else:
            node_gf = None
        node_gs = node_s.lchild
        node_f.rchild = node_gs
        if node_gs:
            node_gs.parent = node_f
        node_s.lchild = node_f
        node_f.parent = node_s
        return node_s,node_gf

    def rotate_right(self,node_f,node_s):   # 右旋
        if node_f.parent:
            node_gf = node_f.parent
        else:
            node_gf = None
        node_gs = node_s.rchild
        node_f.lchild = node_gs
        if node_gs:
            node_gs.parent = node_f
        node_s.rchild = node_f
        node_f.parent = node_s
        return node_s,node_gf

    def rotate_right_left(self,node_f,node_s):      # 先右旋再左旋
        if node_f.parent:
            node_gf = node_f.parent
        else:
            node_gf = None
        node_gs = node_s.lchild
        node_ggs = node_gs.rchild
        node_s.lchild = node_ggs
        if node_ggs:
            node_ggs.parent = node_s
        node_gs.rchild = node_s
        node_s.parent = node_gs

        node_ggs = node_gs.lchild
        node_f.rchild = node_ggs
        if node_ggs:
            node_ggs.parent = node_f
        node_gs.lchild = node_f
        node_f.parent = node_gs
        return node_gs,node_gf

    def rotate_left_right(self,node_f,node_s):      # 先左旋再右旋
        if node_f.parent:
            node_gf = node_f.parent
        else:
            node_gf = None
        node_gs = node_s.rchild
        node_ggs = node_gs.lchild
        node_s.rchild = node_ggs
        if node_ggs:
            node_ggs.parent = node_s
        node_gs.lchild = node_s
        node_s.parent = node_gs

        node_ggs = node_gs.rchild
        node_f.lchild = node_ggs
        if node_ggs:
            node_ggs.parent = node_f
        node_gs.rchild = node_f
        node_f.parent = node_gs
        return node_gs,node_gf

    def insert(self,val):       # 插入节点
        if not self.root:
            self.root = BiTreeNode(val)
            self.root.bf = 0
            return self.root
        node = self.root
        while True:
            if val < node.data:
                if node.lchild:
                    node = node.lchild
                else:
                    node_new = BiTreeNode(val)
                    node.lchild = node_new
                    node_new.parent = node
                    break
            else:
                if node.rchild:
                    node = node.rchild
                else:
                    node_new = BiTreeNode(val)
                    node.rchild = node_new
                    node_new.parent = node
                    break
        node = node_new
        node_order = []     # 用来表示引起变化的节点的来源，来源于左子树，存1，来源与右子树，存-1
        flag_rotate = 0
        while True:     # 节点插入完毕后对节点的bf进行更新。
            node.bf, flag_change2zero = self.bf_update(node)
            if node.bf == -2 or node.bf == 2:   # 遇到某一节点的bf变为2或-2时，停止更新，进行自平衡操作。
                node_f = node
                flag_rotate = 1
                break
            if not node.parent or flag_change2zero == 1:    # 更新到根节点或某一节点的bf变为0，则停止更新。
                break
            else:
                if node.parent.lchild == node:
                    node_order.append(1)
                else:
                    node_order.append(-1)
                node = node.parent
        if flag_rotate:     # 进行自平衡操作。
            if node_order[-1] == -1:
                if node_order[-2] == -1:    # 右右，要左旋
                    node, node_gf = self.rotate_left(node_f, node_f.rchild)
                    node.bf = self.bf_update(node)[0]
                    node.lchild.bf = self.bf_update(node.lchild)[0]
                else:       # 右左，先右旋，再左旋
                    node, node_gf = self.rotate_right_left(node_f,node_f.rchild)
                    node.bf = self.bf_update(node)[0]
                    node.lchild.bf = self.bf_update(node.lchild)[0]
                    node.rchild.bf = self.bf_update(node.rchild)[0]
            else:
                if node_order[-2] == 1:     # 左左，要右旋
                    node, node_gf = self.rotate_right(node_f, node_f.lchild)
                    node.bf = self.bf_update(node)[0]
                    node.rchild.bf = self.bf_update(node.rchild)[0]
                else:       # 左右，先左旋，再右旋
                    node, node_gf = self.rotate_left_right(node_f, node_f.lchild)
                    node.bf = self.bf_update(node)[0]
                    node.lchild.bf = self.bf_update(node.lchild)[0]
                    node.rchild.bf = self.bf_update(node.rchild)[0]
            if node_gf:     # 如果旋转之前的节点有父节点，进行父节点链接。
                if node_gf.lchild == node_f:
                    node_gf.lchild = node
                    node.parent = node_gf
                else:
                    node_gf.rchild = node
                    node.parent = node_gf
            else:       # 如果旋转之前的节点没有父节点，则root节点要在旋转之中，此时需要更新root节点
                node.parent = None
                self.root = node
        return self.root

    def pre_order(self,root):
        if root:
            print(root.data,root.bf, end='  ')
            self.pre_order(root.lchild)
            self.pre_order(root.rchild)

    def in_order(self,root):
        if root:
            self.in_order(root.lchild)
            print(root.data,root.bf, end='  ')
            self.in_order(root.rchild)

AVL数的搜索与删除操作与二叉搜索数一样。删除时需要考虑删除节点的类型：
（1）如果删除的节点为叶子节点，则直接删除。
（2）如果删除的节点只有左子树或右子树，将左子树或右子树直接连于删除节点的父节点，此时需要考虑删除节点是根节点的情况。
（3）如果删除节点有左子树和右子树，此时需要从删除节点的右子树中找值最小的节点放于删除节点的位置。

删除节点后，需要对删除后相关节点的bf进行更新，并进行自平衡操作。

AVL树的建立解析含代码(C++)
会转圈的易拉罐的博客
12-31 916
AVL树 AVL树是平衡二叉树，它可以尽可能创建“枝繁叶茂”的树，防止树枝过长过少。二叉树搜索中，会引入ASL平均查找长度的概念，表示查找所有节点的比较次数平均值。平衡二叉树的ASL相较而言较小。 思路 AVL树就是比较各个节点左右子树的深度差，当差值等于2时就需要对树结构进行改变。改变的方式有左旋、右旋、左右旋以及右左旋。判断旋转方式是看导致深度差值的结点在哪。左旋是顺时针旋转相关结点，右旋为逆时针旋转相关结点。左右旋及右左旋为左旋、右旋的组合，左右旋先右旋后左旋。 如下面图的示例： 以上图片来自陈
AVL树的建立
sinat_41479651的博客
03-09 250
// AVLTree.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include <iostream> #include<algorithm> #include<vector> class AVLNode { public: int data; AVLNode *lchild; AVLNode *rchild; AVLNode(int x) :data(x), lchild(NULL), rchild(NULL) {} i
AVL树的构建
m0_52103105的博客
07-15 290
左子树平衡 右子树平衡 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define LH 1 #define EH 0 #define RH -1 typedef struct tree { int bf; int data; struct tree *left; struct tree *right; }TreeNode,*BiTree; void L_R
构建AVL树
weixin_43796767的博客
06-02 1131
AVL（Adelson-Velskii and Landis）树是满足平衡条件的二叉搜索树：左右子树的深度差不大于1。 一、理解AVL树 目标：通过调整二叉树结构，提高二叉查找的效率。 构建手段：左旋转、右旋转、双旋转。 类似抖葡萄那样，找到合适的节点作为新的根，拎起来抖两下，树结构就得到了调整。 四种失衡情况： 1）LL（left-left）型： 失衡位置从名字可以看出，左子树的左侧挂了太多节点； 此时需要的调整是右旋，顺时针旋转一下，即可恢复平衡。 2）RR（right-right）型 3）LR
AVL树的建立过程
qq_40836518的博客
05-10 2259
原题PTA AVL树是一种平衡的二叉搜索树，每个节点的平衡因子绝对值小于等于1。 分4种情况的旋转： RR右单旋 LL左单旋 LR旋转（通过先右旋再左旋解决） RL旋转（通过先左旋再右旋解决） 题目 An AVL tree is a self-balancing binary search tree. In an AVL tree, the heights of the two chi...
AVL.rar_AVL 存储结构建立删除查找算法的实现
09-23
因此，查找操作的时间复杂度为O(log n)，其中n是树中的节点数。 在`AVL.cpp`文件中，很可能包含了AVL树的数据结构定义、插入、删除和查找函数的实现。这些函数会使用递归或者迭代的方式遍历和操作树的节点，同时...
AVL的建立及其操作
09-04
首先，我们来看AVL树的建立。创建AVL树通常从空树开始，然后通过插入元素来构建。每次插入时，必须检查新插入节点是否导致树失去平衡。如果失去平衡，就需要通过特定的旋转操作来恢复平衡。插入过程分为以下步骤： 1...
avl-Cruise自学教程（有两个整车实例教程）
04-19
1. **模型建立**：创建车辆的基本架构，包括车身、底盘、动力总成等，同时设置各个部分的物理属性，如质量、惯量、几何尺寸等。 2. **发动机模型**：构建发动机模型，包括气缸数量、排量、燃烧特性等，同时设定燃油...
AVL树的c++实现
08-03
AVL树是一种自平衡二叉查找树，它的主要特性是任何节点的两个子树的高度最大差别不超过1，这使得AVL树在查找、插入和删除等操作上的效率相对较高，平均时间复杂度为O(log n)。在C++中实现AVL树，我们可以利用模板类...
AVL树 创建 插入 删除
03-06
对AVL树进行了较为详细的阐述，创建、增加、删除等等
AVL树的创建
乘风破浪Now 的博客
10-05 473
http://www.cnblogs.com/lordage/p/6031616.html?from=timeline&isappinstalled=0
Avl树的建立及其基础操作
Lotuscc的博客
05-30 337
#include&lt;stdio.h&gt;#include&lt;stdlib.h&gt;#define  Max(a,b)    ( (a) &gt; (b) ? (a) : (b))struct AvlNode;typedef struct AvlNode *Position;typedef struct AvlNode *AvlTree; typedef int ElementType;...
AVL树简单构建和基本使用（C++)
Cute_jinx的博客
09-02 665
AVL树的原理挺复杂的，推荐一个博客，原理写得非常详细。 https://blog.csdn.net/howardemily/article/details/79543892 在这我就直接上 简化版的AVL代码吧, 希望对后来者有用。 对于LL AVLtree* opLL() { AVLtree* pa = this, *pb = left, *pc = ((left)-&gt...
如何构建AVL树
qq_62940063的博客
01-23 1594
1.首先我们先定义AVL树的节点 class AVlNode<Integer>{ AVlNode(Integer theElement){ this(theElement,null,null); } AVlNode(Integer theElement,AVlNode<Integer>lt,AVlNode<Integer> rt){ element = theElement; left=lt; right=r
AVL树建立 1066
Tog
05-11 205
#include <iostream> #include <cstdio> #include <string> #include <cstring> #include <algorithm> #include <cmath> #include <stack> #include <queue> #include <map> using namespace std; struct node //建立节
AVL树的类建立
jiangyoujiangyou的专栏
11-02 552
AVL 树是带平衡条件的的而
一篇文章带你轻松手撕AVL树的构建
naititi的博客
12-17 490
我们知道一般情况下二叉搜索树的查找效率是很高的，但是遇到极端情况下时间复杂度就会来到O(N)那么为了消除这种极端情况的影响，我们就需要调节这个二叉树通过一些操作转成一颗二叉平衡树，调节完毕就会得到一颗AVL树。
AVL CRUISE与MATLAB联合仿真教程
在建立联合仿真模型时，必须注意以下事项： - **模型准备**：在模型设计阶段，需正确配置输入输出模块（In和Out），这些模块将作为仿真数据的接口，使得CRUISE与MATLAB之间能够交换数据。 通过这些详细步骤的设置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值