python实现平衡二叉树_Python实现自平衡二叉树AVL

最新推荐文章于 2023-01-02 08:30:36 发布
最新推荐文章于 2023-01-02 08:30:36 发布
阅读量116 收藏
点赞数
文章标签： python实现平衡二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39583162/article/details/111439134
版权

# -*- coding: utf-8 -*-

from enum import Enum

#参考http://blog.csdn.net/niteip/article/details/11840691/

#参考https://www.cnblogs.com/suimeng/p/4560056.html

#todo 还没有考虑高度的增减，只考虑了平衡因子

#todo 加上非递归遍历二叉树

class BFStatus(Enum):

# 左子树的高度减去右子树的高度 RH,EH,LH分别表示右子树较高，左右子树等高，左子树较高

LH = 1

EH = 0

RH = -1

class TreeNode(object):

def __init__(self):

self.lson = None

self.rson = None

self.pnode = None

self.data = None

self.freq = 0

self.hgt = -1

self.bfstatus = BFStatus().EH

class AVLTree(object):

def __init__(self,root_node):

self.root = TreeNode

def height(self,node):

if node is not None:

return node.hgt

return -1

def max(self,campa,campb):

if campa > campb:

return campa

else:

return campb

def single_rotate_right(self, node): # 右单旋转 RR

parent_node = node.pnode

node1 = node.lson

node.lson = node1.rson

node1.rson = node

if parent_node.lson == node:

parent_node.lson = node1

else:

parent_node.rson = node1

node1.pnode = parent_node

node.pnode = node1

def single_rotate_left(self, node): # 左单旋转 LL

parent_node = node.pnode

node1 = node.rson

node.rson = node1.lson

node1.lson = node

if parent_node.lson == node:

parent_node.lson = node1

else:

parent_node.rson = node1

node1.pnode = parent_node

node.pnode = node1

def LeftBalance(self,node):

lchild = node.lson

BFStatus_code = BFStatus()

if lchild.bfstatus == BFStatus_code.EH:

node.bfstatus = lchild.bfstatus = BFStatus_code.LH

lchild.bfstatus = BFStatus.RH

self.single_rotate_right(node)

elif lchild.bfstatus == BFStatus_code.LH:#LL型

node.bfstatus = lchild.bfstatus = BFStatus.EH

self.single_rotate_right(node)

elif lchild.bfstatus == BFStatus.RH:#LR型

rchild = lchild.rson

if rchild.bfstatus == BFStatus.EH:

node.bfstatus = BFStatus.RH

lchild.bfstatus = BFStatus.EH

elif rchild.bfstatus == BFStatus.LH:

node.bfstatus = BFStatus.EH

lchild.bfstatus = BFStatus.LH

elif rchild.bfstatus == BFStatus.RH:

node.bfstatus = BFStatus.EH

lchild.bfstatus = BFStatus.EH

rchild.bfstatus = BFStatus.EH

self.single_rotate_left(lchild)

self.single_rotate_right(node)

def RightBalance(self,node):

rchild = node.rson

BFStatus_code = BFStatus()

if rchild.bfstatus == BFStatus_code.RH:

node.bfstatus = node.bfstatus = BFStatus_code.EH

self.single_rotate_left(node)

elif rchild.bfstatus == BFStatus_code.EH:#LL型

node.bfstatus = rchild.bfstatus = BFStatus.RH

rchild.bfstatus = BFStatus.LH

self.single_rotate_left(node)

elif rchild.bfstatus == BFStatus.LH:#LR型

lchild = rchild.lson

if lchild.bfstatus == BFStatus.LH:

node.bfstatus = BFStatus.EH

rchild.bfstatus = BFStatus.RH

elif lchild.bfstatus == BFStatus.RH:

node.bfstatus = BFStatus.LH

rchild.bfstatus = BFStatus.EH

elif lchild.bfstatus == BFStatus.EH:

node.bfstatus = BFStatus.EH

rchild.bfstatus = BFStatus.EH

lchild.bfstatus = BFStatus.EH

self.single_rotate_right(rchild)

self.single_rotate_left(node)

def insertpri(self,node,data,stack_list,taller_param=True):

if node == None:

node = TreeNode()

node.data = data

node.pnode = stack_list[-1]

else:

stack_list.append(node)

if node.data < data:

(sign,taller) = self.insertpri(node.lson,data,stack_list)

if sign == False:

return (False,taller_param)

if taller == True:

if node.bfstatus == BFStatus().LH:

self.LeftBalance(node)

taller_param = False

elif node.bfstatus == BFStatus().EH:

node.bfstatus = BFStatus().LH

taller_param = True

elif node.bfstatus == BFStatus().RH:

node.bfstatus = BFStatus().EH

taller_param = False

elif node.data > data:

stack_list.append(node)

if node.data < data:

(sign, taller) = self.insertpri(node.rson, data, stack_list)

if sign == False:

return (False, taller_param)

if taller == True:

if node.bfstatus == BFStatus().LH:

node.bfstatus = BFStatus().EH

taller_param = False

elif node.bfstatus == BFStatus().EH:

node.bfstatus = BFStatus().RH

taller_param = True

elif node.bfstatus == BFStatus().RH:

self.RightBalance(node)

taller_param = False

else:

node.freq += 1

return (True,taller_param)

def insert(self,data):

stack_list = []

self.insertpri(self.root,data,stack_list)

def searchpri(self,node,data):

if node is None:

return None

elif node.data > data:

self.searchpri(node.lson,data)

elif node.data < data:

self.searchpri(node.rson,data)

else:

return node

def search(self,data):

self.searchpri(self.root,data)

def go_far_left(self,node):

if node.lson is None:

return node

else:

self.go_far_left(node.lson)

def go_far_right(self,node):

if node.rson is None:

return node

else:

self.go_far_right(node.rson)

def delete_left(self,node,bfchild):

#当bf为-1或1变为0，或者孩子为空时说明子树高降低

if node.lson is None or (bfchild != BFStatus().EH and node.lson.bfstatus == BFStatus().EH):

#左子树树高降低

if node.bfstatus == BFStatus().EH:

node.bfstatus = BFStatus().RH

elif node.bfstatus == BFStatus().LH:

node.bfstatus = BFStatus().EH

elif node.bfstatus == BFStatus().RH:#原本右子树比较高

self.RightBalance(node)

def delete_right(self,node,bfchild):

#当bf为LH或RH变为EH，或者孩子为空时说明子树高降低

if node.rson is None or (bfchild != BFStatus().EH and node.rson.bfstatus == BFStatus().EH):

#左子树树高降低

if node.bfstatus == BFStatus().EH:

node.bfstatus = BFStatus().LH

elif node.bfstatus == BFStatus().RH:

node.bfstatus = BFStatus().EH

elif node.bfstatus == BFStatus().LH:#原本左子树比较高

self.LeftBalance(node)

def deletepri(self,node,data):

bfchild = BFStatus().EH

if node == None:

return None

if node.data > data:

bfchild = node.lson.bfstatus

node.lson = self.deletepri(node.lson,data)

self.delete_left(node,bfchild)

elif node.data < data:

bfchild = node.rson.bfstatus

node.rson = self.deletepri(node.rson, data)

self.delete_left(node, bfchild)

else:

if node.lson is not None: #不是叶子结点并且具有直接前驱

far_right_node = self.go_far_right(node.lson)#直接前驱

node.data = far_right_node.data

node.lson = self.deletepri(node.lson,far_right_node.data)#可以确定，删除的节点为当前节点的左子树的某一个节点

self.delete_left(node,bfchild)

elif node.rson is not None:

far_left_node = self.go_far_left(node.rson)

node.data = far_left_node.data

node.rson = self.deletepri(node.rson,far_left_node.data)

self.delete_right(node,bfchild)

else:#叶子结点

node = None

return node

def delete(self,data):

self.deletepri(self.root,data)

def insubtree(self,node):

if node is None:

return

self.insubtree(node.lson)

print(node.data)

self.insubtree(node.rson)

def traversal(self):

self.insubtree(self.root)

if __name__ == '__main__':

root_node = TreeNode()

tree_obj = AVLTree(root_node)

weixin_39583162
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python算法——平衡二叉树（AVL）
Echo_Wish的博客
11-14 429
AVL树的节点除了包含值之外，还记录了节点的高度。这个高度信息是维持平衡的关键。
【python算法系列十二】平衡二叉树（AVL树）
m0_70372647的博客
05-26 1461
平衡二叉树是一种特别形式的二叉搜索树，它采用平衡化旋转来避免二叉搜索树出现退化的情况。 二叉搜索树的效率 理论上来说，对二叉搜索树进行一次操作的时间复杂度是 O(lgn)，这是因为二叉搜索树在理想状态下是近似于完全二叉树的。但是，在实际操作中，二叉搜索树很容易退化成线性的数据结构。例如，往二叉搜索树中插入一个有序序列，这时会得到一条链，如图 1 所示。 图 1：二叉搜索树退化成线性 这时候，对二叉搜索树进行操作的平均时间复杂度就会退化成 O(n)。左右子树的大小相差巨大的二叉搜索树，就.
python实现二叉树翻转_深入理解平衡二叉树AVL与Python实现
weixin_39630880的博客
12-24 121
前言上一篇文章讨论的二叉搜索树(见 https://www.linuxidc.com/Linux/2019-02/156830.htm)，其时间复杂度最好的情况下是O(log(n))，但是最坏的情况是O(n)，什么时候是O(n)呢？像这样：如果先插入10，再插入20，再插入30，再插入40就会成上边这个样子这个就像是双向链表，我们期望它是下面这个样子：所以我们希望有一种策略能够将第一个图变成第二个...
python实现平衡二叉树的基本操作(创建、遍历、打印)
YTIANYE的博客
07-25 956
目录 平衡二叉树的主要操作 AVL.py tree.py github: 平衡二叉树的主要操作 """FUN0 初始化""" """FUN1 由无序数组创建平衡二叉树 """ """FUN2 向平衡二叉树添加节点 """ """FUN3 将二叉树恢复平衡""" """FUN4 计算每个结点的height""" """FUN5 计算每个结点的balance""" """FUN6 左旋""" """FUN7 右旋""" """
平衡二叉树(AVL)python代码实现，注释超级详细
geosipe的博客
04-27 2914
要了解AVL，就要先了解二叉排序树，二叉排序树（BST）的定义就是： 右子树的所有关键字均不小于根关键字的值。 若它的左子树不空，则左子树上的所有关键字的值均不大于根关键字的值。 若它的右子树不空，则右子树上的所有关键字的值均不小于根关键字的值。 左右子树又各是一颗二叉排序树 写者的二叉排序树基于里面的元素不重复。话不多说直接上代码 class BiTreeNode(object): # 先来定义一下树里面的节点 def __init__(self, data): sel
python实现mysql二叉树_python环境下使用mysql数据及数据结构和二叉树算法（图）...
weixin_39922534的博客
01-29 86
python环境下使用mysql数据及数据结构和二叉树算法(图)：1 python环境下使用mysql2使用的是 pymysql库3 开始-->创建connection-->获取cursor-->操作-->关闭cursor->关闭connection->结束45 代码框架6 import pymysql.cursors7 ###连接数据库8 co...
详解平衡二叉树（AVL树）以及Python实现相关操作
weixin_45666566的博客
08-19 2546
平衡二叉树1、概述2、定义3、失衡二叉排序树的分析与调整3.1 左旋转3.2 右旋转 1、概述 为什么引入平衡二叉树？ \quad \quad含有n个结点的二叉排序树的平均查找长度ASL和树的形态有关 问题： 如何提高形态不均衡的二叉排序树的查找效率？ 解决办法： 做平衡化处理，尽量让二叉树的形状均衡，转换成平衡二叉树。 2、定义 平衡二叉树（balanced binary tree) 又称AVL树（Adelson - VelskII and Landis)。 一棵平衡二叉树或者是空树，或者是具有
Python实现二叉树排序和AVL平衡树的插入
sinat_41893486的博客
03-27 428
下面是python实现二叉树排序代码 ​ sortlist=[4,72,81,6,73,124,65,68,66] class Node(object): def __init__(self,value): self.left=None self.right=None self.parent=None self.value...
python实现平衡二叉树算法的代码
weixin_35754676的博客
01-02 135
平衡二叉树(Balanced Binary Tree)是指一棵二叉树，其中任意节点的两棵子树的高度差不超过 1。常见的平衡二叉树有红黑树、AVL 树等。下面是一个用 Python 实现 AVL 树的简单示例代码： ``` class Node: def init(self, val): self.val = val self.left = None ...
avl_tree:AVL树的python实现（自平衡二叉树）
07-02
avl_tree AVL树的python实现（自平衡二叉树） 描述： 这是具有以下外部方法的平衡二叉搜索树的实现： insert (data) 将数据插入树中，如果它尚未包含在树中insertList (list)通过迭代调用insert将list中的数据元素...
python实现的二叉树定义与遍历算法实例
09-21
### Python 实现的二叉树...本文通过具体的Python代码实现了二叉树的定义和多种遍历方法，并给出了一个平衡二叉树的构建示例。理解并掌握这些基本概念和技术对于学习更复杂的树形结构（如红黑树、AVL树等）非常有帮助。
二叉树_二叉树遍历_二叉树_
10-04
例如，AVL树是一种自平衡二叉搜索树，通过旋转操作保持树的高度平衡，从而保证查找、插入和删除的时间复杂度为O(log n)。红黑树则是一种允许节点倾斜但仍然保持大致平衡的二叉搜索树，它在插入和删除操作中具有良好...
二叉树_二叉树的基础操作_
09-30
此外，二叉树还可以进行其他操作，如查找特定节点、删除节点、判断树是否平衡等。这些操作都是建立在对二叉树结构理解的基础上，通过递归或迭代的方式来实现。 总结来说，二叉树是一种重要的数据结构，它的基础操作...
权重平衡树的python实现
03-30
不同于AVL树（储存子树的高度）和红黑树（储存虚构的“颜色”位），加权平衡树储存记账信息的方式是对应用真正有用的属性：一棵树下元素的数量等于它的根的大小，然而这个根的大小是一个用来实现顺序统计树操作的...
易语言源码易语言http下载模块源码易语言源码易语言http下载模块源码
最新发布
08-05
http，易语言源码易语言http下载模块源码易语言源码易语言http下载模块源码
[毕业设计]VB.NET+Access超市顾客会员管理系统(源代码+论文资料).zip
08-05
[毕业设计]VB.NET+Access超市顾客会员管理系统(源代码+论文资料)
[毕业设计]VB+Access电表数据管理系统设计与实现(源代码+论文).zip
08-05
[毕业设计]VB+Access电表数据管理系统设计与实现(源代码+论文)
埃森哲埃森哲市场洞察分析.pdf
08-05
【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析.pdf【埃森哲】埃森哲市场洞察分析
python实现平衡二叉树代码
08-16
### 回答1： 以下是一个简单的 Python 实现平衡二叉树 (AVL Tree) 的代码示例： ```python class Node: def __init__(self, key): self.key = key self.left = None self.right = None self.height = 1 class AVL_Tree: def insert(self, root, key): if not root: return Node(key) elif key < root.key: root.left = self.insert(root.left, key) else: root.right = self.insert(root.right, key) root.height = 1 + max(self.getHeight(root.left), self.getHeight(root.right)) balance = self.getBalance(root) if balance > 1 and key < root.left.key: return self.rightRotate(root) if balance < -1 and key > root.right.key: return self.leftRotate(root) if balance > 1 and key > root.left.key: root.left = self.leftRotate(root.left) return self.rightRotate(root) if balance < -1 and key < root.right.key: root.right = self.rightRotate(root.right) return self.leftRotate(root) return root def leftRotate(self, z): y = z.right T2 = y.left y.left = z z.right = T2 z.height = 1 + max(self.getHeight(z.left), self.getHeight(z.right)) y.height = 1 + max(self.getHeight(y.left), self.getHeight(y.right)) return y def rightRotate(self, z): y = z.left T3 = y.right y.right = z z.left = T3 z.height = 1 + max(self.getHeight(z.left), self.getHeight(z.right)) y.height = 1 + max(self.getHeight(y.left), self.getHeight(y.right)) return y def getHeight(self, root): if not root: return 0 return root.height def getBalance(self, root): if not root: return 0 return self.getHeight(root.left) - self.getHeight(root.right) ``` 这个代码实现了 AVL 树的基本操作，包括插入节点、左旋、右旋和平衡因子的计算。 使用的时候只需要实例化 AVL_Tree 类，并调 ### 回答2： 平衡二叉树（AVL树）是一种自平衡的二叉搜索树，任何节点的左子树和右子树的高度最多相差1。下面是用Python实现平衡二叉树的代码： ```python # 定义二叉树节点类 class TreeNode: def __init__(self, value): self.data = value self.left = None self.right = None self.height = 1 # 节点的高度，默认为1 # 获取节点的高度 def get_height(node): if node is None: return 0 return node.height # 获取节点的平衡因子 def get_balance(node): if node is None: return 0 return get_height(node.left) - get_height(node.right) # 左旋操作 def left_rotate(z): y = z.right T2 = y.left y.left = z z.right = T2 z.height = max(get_height(z.left), get_height(z.right)) + 1 y.height = max(get_height(y.left), get_height(y.right)) + 1 return y # 右旋操作 def right_rotate(z): y = z.left T3 = y.right y.right = z z.left = T3 z.height = max(get_height(z.left), get_height(z.right)) + 1 y.height = max(get_height(y.left), get_height(y.right)) + 1 return y # 插入节点 def insert_node(root, value): if root is None: return TreeNode(value) elif value < root.data: root.left = insert_node(root.left, value) else: root.right = insert_node(root.right, value) root.height = max(get_height(root.left), get_height(root.right)) + 1 # 检测树的平衡性 balance_factor = get_balance(root) # 左左情况，进行右旋操作 if balance_factor > 1 and value < root.left.data: return right_rotate(root) # 右右情况，进行左旋操作 if balance_factor < -1 and value > root.right.data: return left_rotate(root) # 左右情况，先左旋再右旋 if balance_factor > 1 and value > root.left.data: root.left = left_rotate(root.left) return right_rotate(root) # 右左情况，先右旋再左旋 if balance_factor < -1 and value < root.right.data: root.right = right_rotate(root.right) return left_rotate(root) return root # 中序遍历，打印平衡二叉树 def in_order_traversal(root): if root: in_order_traversal(root.left) print(root.data, end=" ") in_order_traversal(root.right) # 测试代码 root = None root = insert_node(root, 10) root = insert_node(root, 20) root = insert_node(root, 30) root = insert_node(root, 40) root = insert_node(root, 50) root = insert_node(root, 25) print("平衡二叉树：") in_order_traversal(root) ``` 以上代码实现了平衡二叉树的插入操作，并进行了相应的旋转操作来维持平衡。可以通过中序遍历验证平衡二叉树的正确性。 ### 回答3： 平衡二叉树（AVL树）是一种特殊的二叉搜索树，它的左右子树的高度差不超过1。 实现平衡二叉树的代码，主要包含以下几个步骤： 1. 定义二叉树的节点类，包含节点值、左子节点、右子节点和高度等属性。 2. 定义平衡二叉树类，包含插入节点、删除节点、左旋转、右旋转、计算节点高度等方法。 3. 在插入节点、删除节点等操作中，通过判断节点的左子树和右子树的高度差，来判断是否需要进行旋转操作以保持树的平衡。 4. 左旋转和右旋转是平衡二叉树中常用的平衡操作，可以通过调整节点的左右子节点来保持树的平衡。 5. 计算节点的高度时，需要递归计算节点的左子树和右子树的高度，然后取较大值加1作为节点的高度。 6. 实现其他常用方法，如查找节点、遍历树等。 下面是一种可能的Python实现平衡二叉树的代码示例： ```python class TreeNode: def __init__(self, val): self.val = val self.left = None self.right = None self.height = 1 class AVLTree: def __init__(self): self.root = None def insert(self, root, val): if not root: return TreeNode(val) elif val < root.val: root.left = self.insert(root.left, val) else: root.right = self.insert(root.right, val) root.height = 1 + max(self.get_height(root.left), self.get_height(root.right)) balance = self.get_balance(root) if balance > 1 and val < root.left.val: return self.right_rotate(root) if balance < -1 and val > root.right.val: return self.left_rotate(root) if balance > 1 and val > root.left.val: root.left = self.left_rotate(root.left) return self.right_rotate(root) if balance < -1 and val < root.right.val: root.right = self.right_rotate(root.right) return self.left_rotate(root) return root def delete(self, root, val): if not root: return root elif val < root.val: root.left = self.delete(root.left, val) elif val > root.val: root.right = self.delete(root.right, val) else: if not root.left: temp = root.right root = None return temp elif not root.right: temp = root.left root = None return temp temp = self.get_min_value_node(root.right) root.val = temp.val root.right = self.delete(root.right, temp.val) root.height = 1 + max(self.get_height(root.left), self.get_height(root.right)) balance = self.get_balance(root) if balance > 1 and self.get_balance(root.left) >= 0: return self.right_rotate(root) if balance < -1 and self.get_balance(root.right) <= 0: return self.left_rotate(root) if balance > 1 and self.get_balance(root.left) < 0: root.left = self.left_rotate(root.left) return self.right_rotate(root) if balance < -1 and self.get_balance(root.right) > 0: root.right = self.right_rotate(root.right) return self.left_rotate(root) return root def left_rotate(self, z): y = z.right T2 = y.left y.left = z z.right = T2 z.height = 1 + max(self.get_height(z.left), self.get_height(z.right)) y.height = 1 + max(self.get_height(y.left), self.get_height(y.right)) return y def right_rotate(self, z): y = z.left T3 = y.right y.right = z z.left = T3 z.height = 1 + max(self.get_height(z.left), self.get_height(z.right)) y.height = 1 + max(self.get_height(y.left), self.get_height(y.right)) return y def get_height(self, root): if not root: return 0 return root.height def get_balance(self, root): if not root: return 0 return self.get_height(root.left) - self.get_height(root.right) def get_min_value_node(self, root): if root is None or root.left is None: return root return self.get_min_value_node(root.left) def search(self, root, val): if not root or root.val == val: return root elif root.val < val: return self.search(root.right, val) else: return self.search(root.left, val) def inorder_traversal(self, root): res = [] if root: res = self.inorder_traversal(root.left) res.append(root.val) res = res + self.inorder_traversal(root.right) return res ``` 注意，这只是一种可能的实现，实际的代码可能会有所不同。可以根据具体需求和算法原理进行调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值