[从头学数学] 第257节 Python实现数据结构：平衡二叉树(AVL)

最新推荐文章于 2022-10-20 19:47:20 发布
最新推荐文章于 2022-10-20 19:47:20 发布
阅读量791 收藏
点赞数
分类专栏： 从头学数学 从头学数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mwsister/article/details/52447187
版权
剧情提要：
阿伟看到了一本比较有趣的书，是关于《计算几何》的，2008年由北清派出版。很好奇
它里面讲了些什么，就来看看啦。

正剧开始：

星历2016年09月06日 09:52:16, 银河系厄尔斯星球中华帝国江南行省。
[工程师阿伟]正在和[机器小伟]一起研究[计算几何]]。




<span style="font-size:18px;">#
###
# @usage   平衡二叉树
# @author  mw
# @date    2016年07月28日  星期四  15:36:42 
# @param
# @return
#
###
class AVLTree(object):
    def info(self):
        a = [];
        for x in self:
            a.append(x);

        print(a);

    def __iter__(self):
        if self.root != None:
            return self.root.__iter__()
        else:
            return [].__iter__()

    def __contains__(self, val):
        for x in self:
            if (x == val):
                return True;

        return False;

    def __len__(self):
        a = [];
        for x in self:
            a.append(x);

        return len(a);   
        
    class __AVLNode(object):
        def __init__(self, key, height = 0, left = None, right = None):
            self.key=key
            self.left=left
            self.right=right
            self.height=0

        def __iter__(self):
            if self.left != None:
                for elem in self.left:
                    yield elem

            if (self.key != None):
                yield self.key

            if self.right != None:
                for elem in self.right:
                    yield elem

        #迭代的是Node类型，用于删除结点
        def iternodes(self):
            if self.left != None:
                for elem in self.left.iternodes():
                    yield elem

            if self != None and self.key != None:
                yield self

            if self.right != None:
                for elem in self.right.iternodes():
                    yield elem

        def info(self):
            s = 'Key='+str(self.key)+', '+\
                'LChild='+str(self.left)+', '+\
                'RChild='+str(self.right)+', '+\
                'H='+str(self.height);

            print(s);
            
        def __str__(self):
            return str(self.key);

        def __repr__(self):
            if self != None:
                s_1 = str(self.key);
            else:
                s_1 = 'None';

            if self.left != None:
                s_2 = str(self.left.key);
            else:
                s_2 = 'None';

            if self.right != None:
                s_3 = str(self.right.key);
            else:
                s_3 = 'None';

            s_4 = str(self.height);
                
            return '__AVLNode('+s_1+', ' + s_2 +', ' + s_3 +', '+s_4+')';
            
            
        
    def __init__(self):
        self.root=None
        
    def find(self,key):
        if self.root is None:
            return None
        else:
            return self._find(key, self.root)
            
    def _find(self, key, node):
        if node is None:
            return None
        elif key < node.key:
            return self._find(key, self.left)
        elif key > node.key:
            return self._find(key, self.right)
        else:
            return node
    
    #找最小元素
    def findMin(self):
        if self.root is None:
            return None
        else:
            return self._findMin(self.root)        
    
    def _findMin(self,node):
        if node.left:
            return self._findMin(node.left)
        else:
            return node
    
    #找最大元素
    def findMax(self):
        if self.root is None:
            return None
        else:
            return self._findMax(self.root)
            
    def _findMax(self,node):
        if node.right:
            return self._findMax(node.right)
        else:
            return node
    
    #求结点高度
    def height(self, node):
        if (node == None):
            return 0;
        else:
            m = self.height(node.left);
            n = self.height(node.right);
            return max(m, n)+1;
    
    #LL
    def singleLeftRotate(self,node):
        k1=node.left
        node.left=k1.right
        k1.right=node
        node.height=max(self.height(node.right),self.height(node.left))+1
        k1.height=max(self.height(k1.left),node.height)+1
        return k1
    
    #RR
    def singleRightRotate(self,node):
        k1=node.right
        node.right=k1.left
        k1.left=node
        node.height=max(self.height(node.right),self.height(node.left))+1
        k1.height=max(self.height(k1.right),node.height)+1
        return k1
        
    #LR
    def doubleLeftRotate(self,node):
        node.left=self.singleRightRotate(node.left)
        return self.singleLeftRotate(node)
        
    #RL
    def doubleRightRotate(self,node):
        node.right=self.singleLeftRotate(node.right)
        return self.singleRightRotate(node)

    #插入
    def insert(self, key):
        if not self.root:
            self.root=AVLTree.__AVLNode(key)
        else:
            self.root=self._insert(self.root, key)
            
    def _insert(self, node, key):
        if node is None:
            node=AVLTree.__AVLNode(key)
        elif key<node.key:
            node.left=self._insert(node.left, key)
            if (self.height(node.left)-self.height(node.right))==2:
                if key<node.left.key:
                    node=self.singleLeftRotate(node)
                else:
                    node=self.doubleLeftRotate(node)
            
        elif key>node.key:
            node.right=self._insert(node.right, key)
            if (self.height(node.right)-self.height(node.left))==2:
                if key<node.right.key:
                    node=self.doubleRightRotate(node)
                else:
                    node=self.singleRightRotate(node)
        
        
        node.height=max(self.height(node.right),self.height(node.left))+1
        return node

    #删除
    def delete(self, key):
        if key in self:
            self.root=self.remove(key, self.root)
        
    def remove(self, key, node):
        if node is None:
            raise KeyError('Error,key not in tree');
        elif key<node.key:
            node.left=self.remove(key,node.left)
            if (self.height(node.right)-self.height(node.left))==2:
                if self.height(node.right.right)>=self.height(node.right.left):
                    node=self.singleRightRotate(node)
                else:
                    node=self.doubleRightRotate(node)
            node.height=max(self.height(node.left),self.height(node.right))+1            
                
        elif key>node.key:
            node.right=self.remove(key,node.right)
            if (self.height(node.left)-self.height(node.right))==2:
                if self.height(node.left.left)>=self.height(node.left.right):
                    node=self.singleLeftRotate(node)
                else:
                    node=self.doubleLeftRotate(node)
            node.height=max(self.height(node.left),self.height(node.right))+1
            
        elif node.left and node.right:
            if node.left.height<=node.right.height:
                minNode=self._findMin(node.right)
                node.key=minNode.key
                node.right=self.remove(node.key,node.right)
            else:
                maxNode=self._findMax(node.left)
                node.key=maxNode.key
                node.left=self.remove(node.key,node.left)
            node.height=max(self.height(node.left),self.height(node.right))+1
        else:
            if node.right:
                node=node.right
            else:
                node=node.left
        
        return node

    #传回结点的原始信息
    def iternodes(self):
        if self.root != None:
            return self.root.iternodes()
        else:
            return [None];

    #寻找节点路径
    def findNodePath(self, root, node):
        path = [];
        if root == None or root.key == None:
            path = [];
            return path
            
        while (root != node):
            if node.key < root.key:
                path.append(root);
                root = root.left;
            elif node.key >= root.key:
                path.append(root);
                root = root.right;
            else:
                break;

        path.append(root);
        return path;

    #寻找父结点
    def parent(self, root, node):
        path = self.findNodePath(root, node);
        if (len(path)>1):
            return path[-2];
        else:
            return None;

    #是否左孩子
    def isLChild(self, parent, lChild):
        if (parent.getLeft() != None and parent.getLeft() == lChild):
            return True;

        return False;

    #是否右孩子
    def isRChild(self, parent, rChild):
        if (parent.getRight() != None and parent.getRight() == rChild):
            return True;

        return False;

    #求某元素是在树的第几层
    #约定根为0层
    #这个计算和求结点的Height是不一样的
    def level(self, elem):
        if self.root != None:
            node = self.root;
            lev = 0;

            while (node != None):
                if elem < node.key:
                    node = node.left;
                    lev+=1;
                elif elem > node.key:
                    node = node.right;
                    lev+=1;
                else:
                    return lev;

            return -1;

        else:
            return -1;
#</span>


用例：

<span style="font-size:18px;">#
[[2, 0], [3, 0], [4, 0], [10, 1], [12, 0], [13, -1], [18, 0], [39, 0], [40, -1]]
False
9
Key=[2, 0], LChild=None, RChild=None, H=1
[__AVLNode([4, 0], [3, 0], [13, -1], 4), __AVLNode([3, 0], [2, 0], None, 2), __AVLNode([2, 0], None, None, 1)]
Parent: [3, 0]
Level: 2


Key=[3, 0], LChild=[2, 0], RChild=None, H=2
[__AVLNode([4, 0], [3, 0], [13, -1], 4), __AVLNode([3, 0], [2, 0], None, 2)]
Parent: [4, 0]
Level: 1


Key=[4, 0], LChild=[3, 0], RChild=[13, -1], H=4
[__AVLNode([4, 0], [3, 0], [13, -1], 4)]
Parent: None
Level: 0


Key=[10, 1], LChild=None, RChild=[12, 0], H=2
[__AVLNode([4, 0], [3, 0], [13, -1], 4), __AVLNode([13, -1], [10, 1], [39, 0], 3), __AVLNode([10, 1], None, [12, 0], 2)]
Parent: [13, -1]
Level: 2


Key=[12, 0], LChild=None, RChild=None, H=1
[__AVLNode([4, 0], [3, 0], [13, -1], 4), __AVLNode([13, -1], [10, 1], [39, 0], 3), __AVLNode([10, 1], None, [12, 0], 2), __AVLNode([12, 0], None, None, 1)]
Parent: [10, 1]
Level: 3


Key=[13, -1], LChild=[10, 1], RChild=[39, 0], H=3
[__AVLNode([4, 0], [3, 0], [13, -1], 4), __AVLNode([13, -1], [10, 1], [39, 0], 3)]
Parent: [4, 0]
Level: 1


Key=[18, 0], LChild=None, RChild=None, H=1
[__AVLNode([4, 0], [3, 0], [13, -1], 4), __AVLNode([13, -1], [10, 1], [39, 0], 3), __AVLNode([39, 0], [18, 0], [40, -1], 2), __AVLNode([18, 0], None, None, 1)]
Parent: [39, 0]
Level: 3


Key=[39, 0], LChild=[18, 0], RChild=[40, -1], H=2
[__AVLNode([4, 0], [3, 0], [13, -1], 4), __AVLNode([13, -1], [10, 1], [39, 0], 3), __AVLNode([39, 0], [18, 0], [40, -1], 2)]
Parent: [13, -1]
Level: 2


Key=[40, -1], LChild=None, RChild=None, H=1
[__AVLNode([4, 0], [3, 0], [13, -1], 4), __AVLNode([13, -1], [10, 1], [39, 0], 3), __AVLNode([39, 0], [18, 0], [40, -1], 2), __AVLNode([40, -1], None, None, 1)]
Parent: [39, 0]
Level: 3

if __name__ == '__main__':
    avl = AVLTree();

    a = [20, 30, 40, 120, 13, 39, 38, 40, 18, 101];
    b = [[10, 1], [3, 0], [4, 0], [13, -1], [2, 0], [18, 0], [40, -1], [39, 0], [12, 0]];

    for item in b:
        avl.insert(item);

    avl.info();

    print(45 in avl);
    print(len(avl));

    '''
    avl.delete(40);
    avl.info();
    avl.delete(100);
    avl.info();
    avl.insert(1001);
    avl.info();
    '''

    for item in avl.iternodes():
        item.info();
        print(avl.findNodePath(avl.root, item));
        print('Parent:', avl.parent(avl.root, item));
        print('Level:', avl.level(item.key));
        print('\n');

#</span>

本节到此结束，欲知后事如何，请看下回分解。




mwsister
关注
专栏目录
Python算法——平衡二叉树（AVL）
Echo_Wish的博客
11-14 455
AVL树的节点除了包含值之外，还记录了节点的高度。这个高度信息是维持平衡的关键。
算法与数据结构 Python版
10-26
对于初学者来说，Python易于上手且功能强大，非常适合用于学习数据结构和算法。 #### 二、算法分析 **什么是算法分析** 算法分析主要是指评估算法的效率，通常从时间和空间两个维度进行分析。时间复杂度用来衡量...
python--数据结构--平衡二叉排序树
Chasing__Dreams的博客
08-23 545
平衡二叉排序树又称AVL树。 一棵平衡二叉排序树或者是空树，或者是具有下列性质的二叉排序树： 左子树与右子树的高度之差的绝对值小于等于1； 左子树和右子树也是平衡二叉排序树。 引入平衡二叉排序树的目的，是为了提高查找效率，其平均查找长度为O(log₂n)。 结点的平衡因子定义为：结点的左子树深度与右子树深度之差。显然，对一颗平衡二叉排序树而言，其所有结点的平衡因子只能是-1、0或1。当在一个平衡二叉排序树上插入一个结点时，可能导致失衡，即出现绝对值大于1的平衡因子，如2、-2。 一般情况下，只有新插入结
平衡二叉树(AVL)python代码实现，注释超级详细
geosipe的博客
04-27 2991
要了解AVL，就要先了解二叉排序树，二叉排序树（BST）的定义就是： 右子树的所有关键字均不小于根关键字的值。 若它的左子树不空，则左子树上的所有关键字的值均不大于根关键字的值。 若它的右子树不空，则右子树上的所有关键字的值均不小于根关键字的值。 左右子树又各是一颗二叉排序树 写者的二叉排序树基于里面的元素不重复。话不多说直接上代码 class BiTreeNode(object): # 先来定义一下树里面的节点 def __init__(self, data): sel
剑指offer（Python）判断一棵二叉树是否是平衡二叉树
storyfull
12-06 1083
判断一棵二叉树是否是平衡二叉树
【python算法系列十二】平衡二叉树（AVL树）
m0_70372647的博客
05-26 1482
平衡二叉树是一种特别形式的二叉搜索树，它采用平衡化旋转来避免二叉搜索树出现退化的情况。 二叉搜索树的效率 理论上来说，对二叉搜索树进行一次操作的时间复杂度是 O(lgn)，这是因为二叉搜索树在理想状态下是近似于完全二叉树的。但是，在实际操作中，二叉搜索树很容易退化成线性的数据结构。例如，往二叉搜索树中插入一个有序序列，这时会得到一条链，如图 1 所示。 图 1：二叉搜索树退化成线性 这时候，对二叉搜索树进行操作的平均时间复杂度就会退化成 O(n)。左右子树的大小相差巨大的二叉搜索树，就.
算法和数据结构.zip
01-01
在“算法和数据结构.zip”这个压缩包中，我们可以期待找到与数据结构相关的学习资料，虽然具体的子文件"fgsefgergj"的名称无法直接揭示具体内容，但我们可以根据一般的数据结构主题来展开讨论。 数据结构主要包括...
学习数据结构和算法.zip
最新发布
06-17
常见的数据结构有数组、链表、栈、队列、哈希表、树（二叉树、平衡树如AVL和红黑树）、图等。每种数据结构都有其特定的应用场景，选择合适的数据结构能显著提高程序的效率。 数组是最基本的数据结构，它提供了随机...
数据结构算法：此存储库包括我在本科期间所做的数据结构程序和算法。 这些是我自己用C ++从头开始编写的功能齐全的算法。 -要求：Microsoft Visual Studio 2019-打开sln文件以打开整个项目
02-05
- **树**：分层的数据结构，如二叉树、平衡树（AVL、红黑树）、B树等，常用于查找和排序操作。 - **图**：节点和边的集合，用于表示关系或网络结构，如路由算法、社交网络分析等。 2. **算法**： - **排序算法**...
华农数据结构答案
05-02
在“华农数据结构答案”的实验代码中，学生可以学习到如何用C++、Java或Python等编程语言实现这些数据结构和算法，理解它们的内部工作原理，提高问题解决能力。这些实践性的知识对于深入理解数据结构，提升编程技能...
python 平衡二叉树实现代码示例
09-20
主要介绍了python 平衡二叉树实现代码示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
平衡二叉树（AVL树）浅析
10-20
关于平衡二叉树的学习笔记，并提供二叉树平衡、插入及删除的代码、提供一个简单的打印二叉树结构的函数（打印对齐不是很好），方便代码调试。
LeetCode：110（Python）—— 平衡二叉树（简单）
热门推荐
m0_61661179的博客
10-20 5万+
概述：给定一个二叉树，判断它是否是高度平衡的二叉树。一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
判断二叉树为平衡二叉树python实现
桔梗的眼泪博客
06-25 1350
#平衡二叉树：树中任何一个节点它左子树与右子树的高度差不超过1 #利用递归手机信息 # 1 列出可能性 2 整理出返回类型 # 3 整个递归按照同样的结构，得到子树的信息 整合子树 # 的信息、加工出我的信息，往上返回、要求结构一致 class Node(object): def __init__(self,val=None): self.val = val ...
python判断平衡二叉树/对称二叉树
ly17809212771的博客
11-30 823
平衡二叉树 对称二叉树 1.平衡二叉树 给定一个二叉树，判断它是否是高度平衡的二叉树。 一颗高度平衡二叉树定义为：一个二叉树的每个节点的左右两个子树的高度差的绝对值不超过1。 示例1： 输入：root=[3,9,20,null,null,15,7] 输出：true class Solution: def isBalanced(self, root: TreeNode) -> bool: def height(root:TreeNode)->int:
平衡二叉树（python实现）
qq_34741911的博客
07-30 1230
平衡二叉树的定义：首先是棵二叉搜索树，其次它是一课空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树也是一棵平衡二叉树。 平衡二叉树的作用：一般的二叉搜索树，各操作的时间复杂度是（O(log2n)），但是，在某些极端的情况下（如在插入的序列是有序的时），二叉搜索树将退化成近似链或链，此时，其操作的时间复杂度将退化成线性的，即O(n)。我们可以通过随机化建立二叉搜索树来尽量的避免这种...
nodeType(节点类型) 属性值说明
csdn_46884182的博客
09-10 4172
nodeType(节点类型) 属性值说明 文章参考：http://www.maomao365.com/?p=15323 nodeType属性值是一个只读属性，返回一个数字，表示当前节点的类型。 <ul id="container"> <li>列表</li> <li>列表</li> </ul> <script> window.onload = function(){ let obox = document.
平衡二叉树[剑指offer]之python实现
我心中有猛虎 细嗅蔷薇
10-12 3189
题目描述输入一棵二叉树，判断该二叉树是否是平衡二叉树。题目链接# -*- coding:utf-8 -*- # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution: de
高级数据结构：平衡二叉树与AVL树解析
"高级数据结构课程讲解，包括平衡二叉树、可并优先队列、线段树和树状数组基础、RMQ与LCA等主题。由刘汝佳讲解，重点介绍了AVL树的平衡性质和旋转操作，以及如何在插入过程中保持平衡。" 在计算机科学中，高级数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值