【数据结构与算法python】平衡二叉查找树（AVL树）的实现

最新推荐文章于 2023-02-07 20:37:35 发布
最新推荐文章于 2023-02-07 20:37:35 发布
阅读量479 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构与算法 二叉树 平衡二叉树 python AVL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44704985/article/details/108516385
版权

1、定义

二叉树的构建过程中，若元素的插入先后顺序不同，则会影响二叉树最终的结构，因此引入在key插入时一直保持平衡的二叉查找树： AVL树。AVL是发明者的名字缩写： G.M. AdelsonVelskii and E.M. Landis。利用AVL树实现ADT Map， 基本上与BST的实现相同，不同之处仅在于二叉树的生成与维护过程

  • AVL树的实现中， 需要对每个节点跟踪“平衡因子balance factor”参数
  • 平衡因子是根据节点的左右子树的高度来定义的， 确切地说， 是左右子树高度差： balanceFactor =
    height(leftSubTree) -height(rightSubTree)
  • 如果平衡因子大于0，称为“左重left-heavy”，小于零称为“右重right-heavy”，平衡因子等于0，则称作平衡。

如果一个二叉查找树中每个节点的平衡因子都在-1， 0， 1之间， 则把这个二叉搜索树称为平衡树
在这里插入图片描述

2、功能分析

在平衡树操作过程中， 有节点的平衡因子超出此范围， 则需要一个重新平衡的过程，要保持BST的性质！
在这里插入图片描述
既然AVL平衡树确实能够改进BST树的性能， 避免退化情形，我们来看看向AVL树插入一个新key， 如
何才能保持AVL树的平衡性质，首先， 作为BST， 新key必定以叶节点形式插入到AVL树中

  • ❖叶节点的平衡因子是0， 其本身无需重新平衡
  • ❖但会影响其父节点的平衡因子： 作为左子节点插入，则父节点平衡因子会增加1； 作为右子节点插入，则父节点平衡因子会减少1。

在这里插入图片描述
这种影响可能随着其父节点到根节点的路径一直传递上去， 直到：

  • 传递到根节点为止；
  • 或者某个父节点平衡因子被调整到0，不再影响上层节点的平衡因子为止。
    在这里插入图片描述
    重新定义_put方法即可
def _put(self,key,val,currentNode):
    if key < currentNode.key:
        if currentNode.hasLeftChild():
            self._put(key,val,currentNode.leftChild)
        else:
            currentNode.leftChild = TreeNode(key,val,parent=currentNode)
            self.updateBalance(currentNode.leftChild)
    else:
        if currentNode.hasRightChild():
            self._put(key,val,currentNode.rightChild)
        else:
            currentNode.rightChild = TreeNode(key,val,parent=currentNode)
            self.updateBalance(currentNode.rightChild)

UpdateBalance方法

def updateBalance(self,node):
    if node.balanceFactor > 1 or node.balanceFactor < -1:
        self.rebalance(node)
        return
    if node.parent != None:
        if node.isLeftChild():
            node.parent.balanceFactor += 1
        elif node.isRightChild():
            node.parent.balanceFactor -= 1

        if node.parent.balanceFactor != 0:
            self.updateBalance(node.parent)

rebalance重新平衡
主要手段 ：将不平衡的子树进行旋转rotation
视**“左重”或者“右重”进行不同方向的旋转同时更新相关父节点引用，更新旋转后被影响节点的平衡因子**
下图是一个**“右重”子树**A的左旋转（并保持BST性质），将右子节点B提升为子树的根，将旧根节点A作为新根节点B的左子节点，如果新根节点B原来有左子节点，则将此节点设置为A的右子节点（A的右子节点一定有空）
在这里插入图片描述
更复杂一些的情况：如图的“左重”子树右旋转
旋转后，新根节点将旧根节点作为右子节点，但是新根节点原来已有右子节点，需要将原有的右子节点重新定位！
原有的右子节点D改到旧根节点E的左子节点
同样， E的左子节点在旋转后一定有空
在这里插入图片描述

def rebalance(self,node):
    if node.balanceFactor < 0:
        if node.rightChild.balanceFactor > 0:
            # Do an LR Rotation
            self.rotateRight(node.rightChild)
            self.rotateLeft(node)
        else:
            # single left
            self.rotateLeft(node)
    elif node.balanceFactor > 0:
        if node.leftChild.balanceFactor < 0:
            # Do an RL Rotation
            self.rotateLeft(node.leftChild)
            self.rotateRight(node)
        else:
            # single right
            self.rotateRight(node)

def rotateLeft(self,rotRoot):
    newRoot = rotRoot.rightChild
    rotRoot.rightChild = newRoot.leftChild
    if newRoot.leftChild != None:
        newRoot.leftChild.parent = rotRoot
    newRoot.parent = rotRoot.parent
    if rotRoot.isRoot():
        self.root = newRoot
    else:
        if rotRoot.isLeftChild():
            rotRoot.parent.leftChild = newRoot
        else:
            rotRoot.parent.rightChild = newRoot
    newRoot.leftChild = rotRoot
    rotRoot.parent = newRoot
    rotRoot.balanceFactor = rotRoot.balanceFactor + 1 - min(newRoot.balanceFactor, 0)
    newRoot.balanceFactor = newRoot.balanceFactor + 1 + max(rotRoot.balanceFactor, 0)


def rotateRight(self,rotRoot):
    newRoot = rotRoot.leftChild
    rotRoot.leftChild = newRoot.rightChild
    if newRoot.rightChild != None:
        newRoot.rightChild.parent = rotRoot
    newRoot.parent = rotRoot.parent
    if rotRoot.isRoot():
        self.root = newRoot
    else:
        if rotRoot.isRightChild():
            rotRoot.parent.rightChild = newRoot
        else:
            rotRoot.parent.leftChild = newRoot
    newRoot.rightChild = rotRoot
    rotRoot.parent = newRoot
    rotRoot.balanceFactor = rotRoot.balanceFactor - 1 - max(newRoot.balanceFactor, 0)
    newRoot.balanceFactor = newRoot.balanceFactor - 1 + min(rotRoot.balanceFactor, 0)

3、代码实现

class AVLTree(BinarySearchTree):
    def _put(self,key,val,currentNode):
        if key < currentNode.key:
            if currentNode.hasLeftChild():
                self._put(key,val,currentNode.leftChild)
            else:
                currentNode.leftChild = TreeNode(key,val,parent=currentNode)
                self.updateBalance(currentNode.leftChild)
        else:
            if currentNode.hasRightChild():
                self._put(key,val,currentNode.rightChild)
            else:
                currentNode.rightChild = TreeNode(key,val,parent=currentNode)
                self.updateBalance(currentNode.rightChild)                

    def updateBalance(self,node):
        if node.balanceFactor > 1 or node.balanceFactor < -1:
            self.rebalance(node)
            return
        if node.parent != None:
            if node.isLeftChild():
                node.parent.balanceFactor += 1
            elif node.isRightChild():
                node.parent.balanceFactor -= 1

            if node.parent.balanceFactor != 0:
                self.updateBalance(node.parent)

    def rebalance(self,node):
        if node.balanceFactor < 0:
            if node.rightChild.balanceFactor > 0:
                # Do an LR Rotation
                self.rotateRight(node.rightChild)
                self.rotateLeft(node)
            else:
                # single left
                self.rotateLeft(node)
        elif node.balanceFactor > 0:
            if node.leftChild.balanceFactor < 0:
                # Do an RL Rotation
                self.rotateLeft(node.leftChild)
                self.rotateRight(node)
            else:
                # single right
                self.rotateRight(node)

    def rotateLeft(self,rotRoot):
        newRoot = rotRoot.rightChild
        rotRoot.rightChild = newRoot.leftChild
        if newRoot.leftChild != None:
            newRoot.leftChild.parent = rotRoot
        newRoot.parent = rotRoot.parent
        if rotRoot.isRoot():
            self.root = newRoot
        else:
            if rotRoot.isLeftChild():
                rotRoot.parent.leftChild = newRoot
            else:
                rotRoot.parent.rightChild = newRoot
        newRoot.leftChild = rotRoot
        rotRoot.parent = newRoot
        rotRoot.balanceFactor = rotRoot.balanceFactor + 1 - min(newRoot.balanceFactor, 0)
        newRoot.balanceFactor = newRoot.balanceFactor + 1 + max(rotRoot.balanceFactor, 0)


    def rotateRight(self,rotRoot):
        newRoot = rotRoot.leftChild
        rotRoot.leftChild = newRoot.rightChild
        if newRoot.rightChild != None:
            newRoot.rightChild.parent = rotRoot
        newRoot.parent = rotRoot.parent
        if rotRoot.isRoot():
            self.root = newRoot
        else:
            if rotRoot.isRightChild():
                rotRoot.parent.rightChild = newRoot
            else:
                rotRoot.parent.leftChild = newRoot
        newRoot.rightChild = rotRoot
        rotRoot.parent = newRoot
        rotRoot.balanceFactor = rotRoot.balanceFactor - 1 - max(newRoot.balanceFactor, 0)
        newRoot.balanceFactor = newRoot.balanceFactor - 1 + min(rotRoot.balanceFactor, 0)

4、算法分析

AVL树最差情形下的性能：即平衡因子为1或者-1，下图列出平衡因子为1的“左重”AVL树，树的高度从1开始，问题规模（总节点数N）和比对次数（树的高度h）之间的关系为：最多搜索次数h和规模N的关系， 可以说AVL树的搜索时间复杂度为O(log n)
在这里插入图片描述

LaiYoung1022
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python之平衡二叉搜索树（AVL树）
夜空下的凝视
04-15 2013
平衡二叉搜索树（Balanced Binary Tree）： 是一种结构平衡的二叉搜索树，即叶节点高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。它能在O(log n)内完成插入、查找和删除操作，最早被发明的平衡二叉搜索树为AVL树。 常见的平衡二叉搜索树有：AVL树、红黑树、Treap、节点大小平衡树。 注意：移动树的节点时，被移动节点及其原新两个位置的父、子节点的指向均需重新指向，...
AVL树详解（附c++代码）
u012148952的博客
08-14 5249
详解AVL树的左旋和右旋，以及插入和删除两种基本操作。并且实现一颗简单的AVL树
平衡二叉树(AVL)python代码实现，注释超级详细
geosipe的博客
04-27 2752
要了解AVL，就要先了解二叉排序树，二叉排序树（BST）的定义就是： 右子树的所有关键字均不小于根关键字的值。 若它的左子树不空，则左子树上的所有关键字的值均不大于根关键字的值。 若它的右子树不空，则右子树上的所有关键字的值均不小于根关键字的值。 左右子树又各是一颗二叉排序树 写者的二叉排序树基于里面的元素不重复。话不多说直接上代码 class BiTreeNode(object): # 先来定义一下树里面的节点 def __init__(self, data): sel
DS_BST
m0_61758697的博客
10-16 2258
其中BinTree};函数IsBST须判断给定的T是否二叉搜索树，即满足如下定义的二叉树：定义：一个二叉搜索树是一棵二叉树，它可以为空。非空左子树的所有键值小于其根结点的键值。非空右子树的所有键值大于其根结点的键值。左、右子树都是二叉搜索树。如果T是二叉搜索树，则函数返回true，否则返回false。
LeetCode_1670_二叉树的镜像
Fitz的博客
10-16 187
题目链接 https://leetcode-cn.com/problems/er-cha-shu-de-jing-xiang-lcof/ 解题思路 使用递归来做，遍历二叉树，交换每个节点的左右子节点 终止条件：当节点root为空时 初始化节点tmp，用于暂存root的左子节点 root.left = mirrorTree(root.right) root.right = mirrorTree(tmp) AC代码 class Solution { public TreeNo
基于Python实现的数据结构与算法完整源代码+超详细注释(包含46个作业项目).zip
最新发布
01-02
基于Python实现的数据结构与算法完整源代码+超详细注释(包含46个作业项目) 项目包含： 01_变位词问题 02_python数据类型的性能 03_python实现ADT Stack 04_栈的应用1括号匹配 05_栈的应用2十进制转二进制 06_栈的...
Python 中不同数据结构或算法的实现，包括 ADT、哈希表、链表、排序、树和图
06-07
二叉搜索树操作： 插入 插入列表 寻找 删除 遍历BFS 遍历DFS前序 遍历DFSinorder 遍历DFS后序 复制树 找最小值 查找最大值 类型： 迭代（使用 Queue(head ptr) 和 Stack 进行遍历） 递归（继承自迭代方法，重新实现 ...
数据结构与算法的介绍及应用
11-30
二叉排序树查找,Python3 数据结构与算法的... 查找算法： 顺序查找、二分查找、哈希表查找、二叉查找树、平衡二叉查找树(AVL树、红黑树)、平衡多路查找树(B树、B+树)；4. LeetCode 和《剑指Offer》刷题、多种方法的题解
算法/数据结构/Python/剑指offer/机器学习/leetcode
05-29
算法/数据结构/Python/剑指offer/机器学习/leetcode 数据结构markdown格式 链表及常见操作 平衡查找树AVL 三种方法检测变位词Anagram 构建堆 二分查找 二叉查找树 二叉树 冒泡排序 英语单词拼写检查算法 ...
数据结构头歌：第七章- 平衡二叉树-测试详解（平衡因子，最大深度，分支节点，斐波那契数列）
Molly 的博客
02-07 1627
一、单选题 1.若将关键字1，2, 3, 4, 5, 6, 7依次插入到初始为空的平衡二叉树T中，则T中的平衡因子为0的分支结点的个数是: 2.若平衡二叉树的高度为6，且所有非叶子结点的平衡因子均为1,则改平衡二叉树的结点总数为: 20 3.下列二叉搜索树中，满足平衡二叉树定义的是 二、填空题(共3题，共20.0分) 1.若平衡二叉树的深度是6 (空树的深度定义为-1)，则该树的最少结点数是:20 2.12个结点的AVL树的最大深度是：5平衡二叉树=AVL树 3.在下列所示的平衡二叉树中
AVL树及其C++实现
Nim的辙迹
01-26 4317
AVL树（高度平衡二叉树）的介绍及其C++实现
平衡搜索二叉树的python实现
林贻民的博客
07-25 3015
我的代码片:https://code.csdn.net/snippets_manage# BST为二叉搜索树的实现文件 import BST''' 功能:往平衡二叉树中插入一个结点 参数: N:要插入的结点 ''' def BInsert(N): # 调用二叉树的插入函数插入元素 BST.Insert(N) # 找出刚插入的元素,更新结点的高
python平衡搜索二叉树
william_djj的专栏
03-12 618
平衡二叉树的实现，python， # -*- coding: UTF-8 -*- #!/usr/bin/python #from __future__ import print_function #python2.7不要注释这句 class AVLnode: def __init__(self, d, h=0, l=None, r=None ): sel...
Python 二叉搜索树
dta0502的博客
06-25 3204
树集合有三个重要的分类，树就属于其中的层级结构。大多数编程语言并没有将树作为一种标准类型包含其中，尽管如此，树还是得到了广泛的应用，它可以很自然的表示物体的集合，例如，一个文件的目录结构和一本书的目录。树的两个主要特征：（1）每个项都有多个子节点（2）除了叫做根的特殊的项，所有其他的项都只有一个父节点二叉树这里有两种极端情况：（1）分叉状，带有N个节点并且高度为N-1这样的树类似于链表列表中的一个...
Python实现"平衡二叉树"的一种方法
qiubingcsdn的博客
09-04 1693
判断给定的二叉树是不是平衡二叉树 本文体中，高平衡二叉树定义为：二叉树中任意结点的左右子树深度差不超过1 Example 1: Given the following tree [3,9,20,null,null,15,7]: 3 / \ 9 20 / \ 15 7 Return true.Example 2: Given the follo...
AVL Tree Implementation 自平衡二叉搜索树的实现
rede
02-19 1648
AVL Tree Implementation 自平衡二叉搜索树的实现   学习资料： CSDN:【数据结构】AVL树详解 百度词条:AVL树 在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者G. M. Adelson-Vels...
二叉树类图_作业-平衡二叉树AVLTree的实现与应用(难度5/10)
weixin_31297157的博客
01-01 144
这是目前难度最高的一个作业，主要难点在于树的平衡，树的平衡依赖于调试输出的图形化，也就是输出二叉树的实现，二叉树的输出技巧性比较强，一般人很难直接想到控制台可以打印二叉树。后面的测试结果显示本文实现的AVLTree 4次战胜std::map。C++数据结构与算法夯实基础作业列表平衡部分的调试最好用很少很少量的数据，把各种情况跑一遍，因为一旦不考虑测试集的大小，容易给自己添麻烦。测试集大了之后，调试...
AVL树（平衡二叉树）
蜗@牛的博客
07-08 522
一、AVL树简介 AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树（Self-Balancing Binary Search Tree,简称平衡二叉树）。 平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉排序树...
数据结构作业20—动态查找表（选择题）
热门推荐
banya1999的博客
12-23 1万+
2-1在下列所示的平衡二叉树中，插入关键字48后得到一棵新平衡二叉树。在新平衡二叉树中，关键字37所在结点的左、右子结点中保存的关键字分别是： (2分) A.24、53 B.24、90 C.24、48 D.13、48 作者: DS课程组 单位: 浙江大学 2-2下列二叉搜索树中，满足平衡二叉树定义的是： (1分) A B C D 作者: DS课程组 单位: ...
python 用AVL树实现字典类型
05-17
AVL树是一种自平衡二叉搜索树，可以用来实现字典类型。在实现字典类型时，我们可以将键值对存储在AVL树的节点中，其中键作为节点的关键字，值则作为节点的附加数据。 下面是一个简单的AVL树实现字典类型的Python代码： ```python class AVLNode: def __init__(self, key, val): self.key = key self.val = val self.left = None self.right = None self.height = 1 class AVLTree: def __init__(self): self.root = None def insert(self, key, val): self.root = self._insert(self.root, key, val) def _insert(self, node, key, val): if not node: return AVLNode(key, val) if key < node.key: node.left = self._insert(node.left, key, val) elif key > node.key: node.right = self._insert(node.right, key, val) else: node.val = val node.height = 1 + max(self._height(node.left), self._height(node.right)) balance = self._get_balance(node) if balance > 1 and key < node.left.key: return self._right_rotate(node) if balance < -1 and key > node.right.key: return self._left_rotate(node) if balance > 1 and key > node.left.key: node.left = self._left_rotate(node.left) return self._right_rotate(node) if balance < -1 and key < node.right.key: node.right = self._right_rotate(node.right) return self._left_rotate(node) return node def search(self, key): node = self._search(self.root, key) if node: return node.val else: return None def _search(self, node, key): if not node: return None if key == node.key: return node if key < node.key: return self._search(node.left, key) else: return self._search(node.right, key) def _height(self, node): if not node: return 0 return node.height def _get_balance(self, node): if not node: return 0 return self._height(node.left) - self._height(node.right) def _left_rotate(self, node): new_root = node.right node.right = new_root.left new_root.left = node node.height = 1 + max(self._height(node.left), self._height(node.right)) new_root.height = 1 + max(self._height(new_root.left), self._height(new_root.right)) return new_root def _right_rotate(self, node): new_root = node.left node.left = new_root.right new_root.right = node node.height = 1 + max(self._height(node.left), self._height(node.right)) new_root.height = 1 + max(self._height(new_root.left), self._height(new_root.right)) return new_root ``` 在这个实现中，我们定义了AVLNode类来表示AVL树的节点。每个节点包含一个键、一个值、左右子树指针以及节点高度。AVLTree类是AVL树的实现，包含了插入、搜索、左旋和右旋等基本操作。 在insert操作中，我们首先按照二叉搜索树的规则找到要插入的位置。然后更新节点高度，并计算平衡因子。如果平衡因子超过了1或-1，我们就需要进行旋转来保持AVL树的平衡。 在search操作中，我们按照二叉搜索树的规则搜索键值对应的节点，并返回其值。 这个AVL树实现可以用来实现字典类型。我们可以将键值对存储在AVL树的节点中，并通过搜索操作来查找键对应的值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值