python AVL树的插入

最新推荐文章于 2023-01-15 22:15:45 发布
最新推荐文章于 2023-01-15 22:15:45 发布
阅读量437 收藏 1
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012164509/article/details/103146070
版权

key 关键字项
bf 平衡因子
data 其它数据域
lchild rchild 左右孩子

左
在这里插入图片描述

右

在这里插入图片描述

#右选 左旋
在这里插入图片描述
往右偏移说明插入在s3上了,s3s是h，s2是h-1

#左旋 右旋
在这里插入图片描述

#下面的代码是右边减左边，其实应该是左边减右边的

from bst import BiTreeNode,BST


#下面的代码是右边减左边，其实应该是左边减右边的

class AVLNode(BiTreeNode):
        def __init__(self,data):
                BiTreeNode.__init__(self,data)
                self.bf = 0


class AVLTree(BST):
        def __init__(self,li=None):
                BST.__init__(self,li)

        #左旋
        def rotate_left(self,p,c):
                #s2 是c的左子树
                s2 = c.lchild
                p.rchild =s2
                if s2:
                        #父亲连过来,孩子也要连回去
                        s2.parent = p
                c.lchild = p
                p.parent = c

                p.bf = 0
                c.bf = 0
                return c


        def insert_no_rec(self,val):
                s2 = c.rchild
                p.lchild = s2
                if s2:
                        s2.parent = p
                c.rchild = p
                p.parent = c
                p.bf = 0
                c.bf = 0
                return c

        #右选左旋 
        def rotate_right_left(self,p,c):
                g = c.lchild
                #s3 是g的右孩子
                s3 = g.rchild
                #s3绑到c的左孩子上   
                c.lchild = s3
                #反着连回去就要判断是否为空 
                if s3:
                        s3.parent = c
                #下面c和g交互了
                #c 是g的右孩子 
                g.rchild = c
                #g 是c的父亲 
                c.parent = g

                #s2 是g的左孩子         
                s2 = g.lchild
                #现在p的右孩子 等于s2
                p.rchild = s2

                if s2:
                        s2.parent = p

                g.lchild = p
                p.parent = g

                #更新 bf  插入s3   大于0就是等于1 是往右偏移
                if g.bf > 0 :
                        p.bf = -1
                        c.bf = 0
                elif g.bf < 0 : #插入s2 左边
                        p.bf = 0
                        c.bf = 1

                else:  #特殊情况，G插入进去来 刚插入进来的是叶子根节点， 所以等于0   G =0 
                        p.bf = 0
                        c.bf = 0
                #旋转之后的根
                return g

        #先左旋后右选 
        def rotate_left_right(self,p,c):
                g = c.rchild

                s2 = g.lchild
                c.rchild = s2

                if s2:
                        s2.parent = c

                g.lchild = c
                c.parent = g

                s3 = g.rchild
                p.lchild = s3

                if s3:
                        s3.parent = p

                g.rchild = p
                p.parent = g

                #更新 
                if g.bf < 0:
                        p.bf = 1
                        c.bf = 0
                elif g.bf > 0:
                        p.bf = 0
                        c.bf = -1

                else:
                        p.bf = 0
                        c.bf = 0

        #代码从左往右读 
        def insert_no_rec(self,val):
                #如果传递或者插入 有一个节点。balance变成0,停止了       
                #如果变成2或者-2 就不平衡了 
                # 1. 和BST一样，插入
                p = self.root
                if not p:  # 空树
                        self.root = AVLNode(val)
                        return
                while True:
                        #来的值要比当前的节点要小 左子树
                        if val < p.data:
                                if p.lchild:
                                        #如果有 父亲指向了孩子
                                        p = p.lchild
                                else:  # 左孩子不存在插入这个位置，插入到p.lchild的位置上
                                        p.lchild = AVLNode(val)
                                        #孩子指向了父亲 
                                        p.lchild.parent = p
                                        #保存这个元素插入的位置 
                                        node = p.lchild # node 存储的就是插入的节点
                                        break
                        elif val > p.data:
                                if p.rchild:
                                        p = p.rchild
                                else:
                                        p.rchild = AVLNode(val)
                                        p.rchild.parent = p
                                        node = p.rchild
                                        break
                        else:   # val == p.data  同样的元素不能多次插入 
                                return

                #右沉左旋，左沉右选             
                #更新balance factor  从它的父亲网上更新
                while node.parent:  # node.parent不空  保证node的从父亲开始
                        #左孩子-1  右孩子+1
                        if node.parent.lchild == node: # 传递是从左子树来的，左子树更沉了 插入的
                        #更新node.parent的bf -= 1  减1  这是父亲
                                if node.parent.bf < 0: # 原来node.parent.bf == -1, 更新后变成-2
                                        # 做旋转
                                        # 看node哪边沉
                                        x = node.parent  # 旋转前的子树的根
                                        #右沉 这是子
                                        if node.bf > 0:
                                                #旋转之后的新的根
                                                n = self.rotate_left_right(node.parent, node)
                                        else:
                                                n = self.rotate_right_left(node.parent, node)
                                        # 记得：把n和g连起来
                                elif node.parent.bf > 0: # 原来node.parent.bf = 1，更新之后变成0
                                        #更新之后减1 变成零   等于0就不再传递了
                                        node.parent.bf = 0
                                        break
                                else: # 原来node.parent.bf = 0，更新之后变成-1  
                                        node.parent.bf = -1
                                        #网上继续走 继续看
                                        node = node.parent
                                        continue
                        else: # 传递是从右子树来的，右子树更沉了 插入
                                #更新node.parent.bf += 1
                                #这是父亲
                                if node.parent.bf > 0:  # 原来node.parent.bf == 1, 更新后变成2
                                        # 做旋转
                                        # 看node哪边沉
                                        g = node.parent.parent # 为了连接旋转之后的子树
                                        x = node.parent  # 旋转前的子树的根
                                        #这是子
                                        if node.bf < 0: # node.bf = 1
                                                 #旋转之后的新的根
                                                n = self.rotate_right_left(node.parent, node)
                                        else:   # node.bf = -1
                                                n = self.rotate_left(node.parent, node)
                                        # 记得连起来
                                elif node.parent.bf < 0: # 原来node.parent.bf = -1，更新之后变成0
                                        node.parent.bf = 0
                                        break
                                else: # 原来node.parent.bf = 0，更新之后变成1
                                        node.parent.bf = 1
                                        node = node.parent
                                        continue

                        # 链接旋转后的子树
                        n.parent = g
                        if g: # g不是空
                                if x == g.lchild:
                                        g.lchild = n
                                else:
                                        g.rchild = n
                                break
                        else:
                                self.root = n
                                break



tree = AVLTree([9,8,7,6,5,4,3,2,1])
tree.pre_order(tree.root)
print("")
tree.in_order(tree.root)

二叉搜索树

import random

class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None   # 左孩子
        self.rchild = None  # 右孩子
        self.parent = None

class BST:
    def __init__(self, li=None):
        self.root = None
        if li:
            for val in li:
                self.insert_no_rec(val)

    def insert(self, node, val):
        if not node:
            node = BiTreeNode(val)
        elif val < node.data:
            node.lchild = self.insert(node.lchild, val)
            node.lchild.parent = node
        elif val > node.data:
            node.rchild = self.insert(node.rchild, val)
            node.rchild.parent = node
        return node

    def insert_no_rec(self, val):
        p = self.root
        if not p:               # 空树
            self.root = BiTreeNode(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:           # 左孩子不存在
                    p.lchild = BiTreeNode(val)
                    p.lchild.parent = p
                    return
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = BiTreeNode(val)
                    p.rchild.parent = p
                    return
            else:
                return

    def query(self, node, val):
        if not node:
            return None
        if node.data < val:
            return self.query(node.rchild, val)
        elif node.data > val:
            return self.query(node.lchild, val)
        else:
            return node

    def query_no_rec(self, val):
        p = self.root
        while p:
            if p.data < val:
                p = p.rchild
            elif p.data > val:
                p = p.lchild
            else:
                return p
        return None

    def pre_order(self, root):
        if root:
            print(root.data, 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, end=',')
            self.in_order(root.rchild)

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


    def __remove_node_1(self, node):
        # 情况1：node是叶子节点
        if not node.parent:
            self.root = None
        if node == node.parent.lchild:  #node是它父亲的左孩子
            node.parent.lchild = None
        else:   #右孩子
            node.parent.rchild = None

    def __remove_node_21(self, node):
        # 情况2.1：node只有一个左孩子
        if not node.parent: # 根节点
            self.root = node.lchild
            node.lchild.parent = None
        elif node == node.parent.lchild:
            node.parent.lchild = node.lchild
            node.lchild.parent = node.parent
        else:
            node.parent.rchild = node.lchild
            node.lchild.parent = node.parent

    def __remove_node_22(self, node):
        # 情况2.2：node只有一个右孩子
        if not node.parent:
            self.root = node.rchild
        elif node == node.parent.lchild:
            node.parent.lchild = node.rchild
            node.rchild.parent = node.parent
        else:
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent


    def delete(self, val):
        if self.root:   # 不是空树
            node = self.query_no_rec(val)
            if not node: # 不存在
                return False
            if not node.lchild and not node.rchild: #1. 叶子节点
                self.__remove_node_1(node)
            elif not node.rchild:       # 2.1 只有一个左孩子
                self.__remove_node_21(node)
            elif not node.lchild:       # 2.2 只有一个右孩子
                self.__remove_node_22(node)
            else:   # 3. 两个孩子都有
                min_node = node.rchild
                while min_node.lchild:
                    min_node = min_node.lchild
                node.data = min_node.data
                # 删除min_node
                if min_node.rchild:
                    self.__remove_node_22(min_node)
                else:
                    self.__remove_node_1(min_node)




#
#

tree = BST([1,4,2,5,3,8,6,9,7])
tree.pre_order(tree.root)
print("")
tree.in_order(tree.root)
print("")
tree.post_order(tree.root)
print("")

#
# tree.delete(4)
# tree.delete(1)
# tree.delete(8)
# tree.in_order(tree.root)

在这里插入图片描述

伟伟哦
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
avl_tree:AVL树的python实现（自平衡二叉树）
07-02
avl_tree AVL树的python实现（自平衡二叉树） 描述： 这是具有以下外部方法的平衡二叉搜索树的实现： insert (data) 将数据插入树中，如果它尚未包含在树中 insertList (list)通过迭代调用insert将list中的数据元素插入到树中 如果数据在树中，则包含（数据）返回 True，否则返回 False str () 使用 BFS 遍历漂亮地打印树（用于测试目的） 其余的是用于维护 AVL 树要求的内部例程。 要测试树，请导航到 shell 中的 avl_tree 目录并键入： $ python 进入python解释器。 （确保解释器的路径 - 通常 /usr/local/bin/python 在 shell 的路径中）。 然后输入： >>> from tree import * 从 tree.py 导入类。 使用以下内容测试树：
【python算法系列十二】平衡二叉树（AVL树）
m0_70372647的博客
05-26 1397
平衡二叉树是一种特别形式的二叉搜索树，它采用平衡化旋转来避免二叉搜索树出现退化的情况。 二叉搜索树的效率 理论上来说，对二叉搜索树进行一次操作的时间复杂度是 O(lgn)，这是因为二叉搜索树在理想状态下是近似于完全二叉树的。但是，在实际操作中，二叉搜索树很容易退化成线性的数据结构。例如，往二叉搜索树中插入一个有序序列，这时会得到一条链，如图 1 所示。 图 1：二叉搜索树退化成线性 这时候，对二叉搜索树进行操作的平均时间复杂度就会退化成 O(n)。左右子树的大小相差巨大的二叉搜索树，就.
AVL树平衡旋转详解
Marcus-Bao的个人主页
03-13 5064
感谢大佬！感谢大佬！概述 AVL树又叫做平衡二叉树。前言部分我也有说到，AVL树的前提是二叉排序树(BST或叫做二叉查找树)。由于在生成BST树的过程中可能会出现线型树结构，比如插入的顺序是：1, 2, 3, 4, 5, 6, 7..., n。在BST树中，比较理想的状况是每个子树的左子树和右子树的高度相等，此时搜索的时间复杂度是log(N)。可是，一旦这棵树演化成了线型树的时候，这个理想的情况...
AVL树插入(Python实现)
weixin_30823001的博客
04-11 385
建立AVL树 1 class AVLNode(object): 2 def __init__(self,data): 3 self.data = data 4 self.lchild = None 5 self.rchild = None 6 self.parent = None 7 ...
Python之AVL树
Cauchy的博客
04-14 1287
文章目录AVL树（平衡二叉树）总结 AVL树（平衡二叉树） 方法 功能 find(data) 查找值为data的节点是否存在树中 height() 返回当前树高 insert(data) 插入值为data的节点 delete(data) 删除值为data的节点 get_pre(root) 返回root节点的前驱 inorder(root) 中序遍历 #节点类。AVL树相对一般二叉搜索树，节点增加树高属性，便于判断是否平衡，从而决定是否进行调整等。 class Node
【零基础】学python数据结构与算法笔记12-AVL树
weixin_56760882的博客
01-15 468
学习python数据结构与算法，学习常用的算法，b站学习链接二叉搜索树拓展应用B树（B-Tree）:B树是一颗自平衡的多路搜索树。常用于数据库的索引。哈希表也可以用做数据库的索引。还有一种在此之上的改进叫B+树（B+Tree）大同小异这个是3叉的B树，中间存两个数据17，35。比17小的存左边，17-35存右边，比17大的存右边。分成了三个块，查找时更块。学习了AVL树，数据结构到此告一段落。
用python实现AVL树、B树、红黑树的插入、查找和删除操作
最新发布
10-16
用python实现AVL树、B树、红黑树的插入、查找和删除操作。并且记录三颗查找树完成一定数量级的插入、查找和删除操作所经历的时间。
平衡二叉树（AVL树）浅析
10-20
关于平衡二叉树的学习笔记，并提供二叉树平衡、插入及删除的代码、提供一个简单的打印二叉树结构的函数（打印对齐不是很好），方便代码调试。
权重平衡树的python实现
03-30
不同于AVL树（储存子树的高度）和红黑树（储存虚构的“颜色”位），加权平衡树储存记账信息的方式是对应用真正有用的属性：一棵树下元素的数量等于它的根的大小，然而这个根的大小是一个用来实现顺序统计树操作的...
AVLTree：具有以下操作的通用AVL树实现：插入，删除，搜索，上下限，最近的元素，范围内的值等
02-25
问题：AVL树目的：了解平衡二叉搜索树的端到端知识，以及如何将其有效地用于解决各种问题。 任务：通过以下操作实现AVL树。 要实施的操作： Operations Complexity 1. Insertion O(log N) 2. Deletion O(log N) 3. ...
AVL树与红黑树实现（可视化界面）
03-14
本人实现的 AVL树与红黑树，具有可视化界面，代码清晰。
python--树--AVL树
qq_44525050的博客
02-20 1441
AVL树（平衡树） 1.本质：一棵二叉查找树 2.定义：带有平衡条件的查找树，是一种特殊的二叉查找树，又称平衡二叉树 3特点：是一颗空树或其左右子树高度差不大于1，并且两个子树都是一颗平衡二叉树 4.AVL树的基本操作：插入和删除。 在删除的时候可能会破坏树的平衡性，因此删除造成的操作，是不需要考虑的。AVL树的插入分为两大类—单旋转和双旋转，其中1）单旋转：分左旋转和右旋转；2）双旋转：分先局部...
python AVL树(详细注释)
Wang_Runlin的博客
03-10 1582
        AVL树本质是二叉搜索树，但它又具有以下特点：只能是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树也分别满足同样条件。在AVL树中任何结点的两个子树的高度最大差别为一，所以它也被称为平衡二叉树。 #AVL树（二叉平衡树） #节点类。AVL树相对一般二叉搜索树，节点增加树高属性，便于...
平衡二叉树(AVL)python代码实现，注释超级详细
geosipe的博客
04-27 2691
要了解AVL，就要先了解二叉排序树，二叉排序树（BST）的定义就是： 右子树的所有关键字均不小于根关键字的值。 若它的左子树不空，则左子树上的所有关键字的值均不大于根关键字的值。 若它的右子树不空，则右子树上的所有关键字的值均不小于根关键字的值。 左右子树又各是一颗二叉排序树 写者的二叉排序树基于里面的元素不重复。话不多说直接上代码 class BiTreeNode(object): # 先来定义一下树里面的节点 def __init__(self, data): sel
(数据结构)[python]（14）----AVL树
qq_42115732的博客
02-19 164
AVL树(平衡二叉树)： AVL树本质上是一颗二叉查找树，但是它又具有以下特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为平衡二叉树。下面是平衡二叉树和非平衡二叉树对比的例图： 　　 　　　　平衡因子(bf)： 结点的左子树的深度减去右子树的深度，那么显然-1&amp;lt;=bf&amp;lt;=1...
【Python数据结构】——二叉平衡树AVL（查找、构建、删除、插入、打印、遍历）
python_AI_fans的博客
07-29 621
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2021/7/28 20:57 # @Author : @linlianqin # @Site : # @File : 二叉平衡树专题（创建、插入、查找）.py # @Software: PyCharm # @description: ''' 二叉平衡树的特点：在二叉查找树的基础上对每一个节点的左右子树的高度进行了规定——每一个节点的左右子树的高度差不超过1 1）任何一.
python数据结构学习笔记-2016-12-10-01-AVL树
mengzm的博客
12-31 921
14.3 AVL树         AVL树由G.M.Adel‘son-Velskii和Y.M.Landis在1962年发明的自平衡二叉查找树。如果一个二叉树，其左右两子树的高度最多相差1，则称该二叉树是平衡的(balanced)。         对于AVL树中的每一个结点，都有一个平衡因子(balance factor)，以表示该结点的左右两分支的高度差，平衡因子有三种状态：
Python实现AVL树
Fudanqqqqq的博客
05-07 1349
class Node: def __init__(self,key): self.key=key self.left=None self.right=None self.height=0 class AVLTree: def __init__(self): self.root=None def ...
AVL树的python实现
Magic1an的博客
12-23 2958
AVL树是一种自平衡二叉树，他要求左右子树的高度相差不能超过1. python实现代码如下：#coding:utf-8 class TreeNode(object): def __init__(self): self.data=0 self.left=None self.right=None self.height=0 cla
python实现avl树
05-26
下面是一个简单的 Python 实现 AVL 树的例子： ```python # AVL Tree Implementation in Python # Create Node Class class AVLNode: ...这是一个基本的实现，可以用来插入、删除和打印 AVL 树。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

伟伟哦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值