Python实现二叉树排序和AVL平衡树的插入

最新推荐文章于 2022-04-27 15:54:54 发布
最新推荐文章于 2022-04-27 15:54:54 发布
阅读量425 收藏 1
点赞数
分类专栏： 排序 文章标签： 二叉树排序 平衡二叉树 AVL python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_41893486/article/details/79708033
版权

下面是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=value

def buidtree(tree):   #   返回非空节点个数
    if tree==None:
        return 0
    elif tree.left==None and tree.right==None:
        return 1
    return buidtree(tree.left)+buidtree(tree.right)+1
    
def createTree(tree,value):    #  创建树
    if tree.left==None:
        tree.left=Node(value)
        tree.left.parent=tree
        return
    elif tree.right==None:
        tree.right=Node(value)
        tree.right.parent=tree
        return
    if buidtree(tree.left)-buidtree(tree.right)*2==1:   #   判断加入左还是右
        createTree(tree.right,value)
    else:
        createTree(tree.left,value)


root=Node(sortlist[0])
for i in sortlist[1:]:
    createTree(root,i)

def falstbult(tree):    #   先序遍历
    if tree==None:
        return []
    else:
        return [tree.value]+falstbult(tree.left)+falstbult(tree.right)

def mbult(tree):    #   中序遍历
    if tree==None:
        return []
    else:
        return mbult(tree.left)+[tree.value]+mbult(tree.right)
    
def paixu(node,ccount,change):   #   排序
    if node==None or node.left==None:
        return ccount,change
    elif node.right==None:
        if node.value<node.left.value:
            ccount+=1
            change=True
            tmpe=node.value 
            node.value=node.left.value   #   局部排序    
            node.left.value=tmpe
        return ccount,change
    else :
        if node.value<node.left.value:
            ccount+=1
            change=True
            tmpe=node.value 
            node.value=node.left.value   #   局部排序    
            node.left.value=tmpe
        if node.right.value<node.value:
            ccount+=1
            change=True
            tmpe=node.value 
            node.value=node.right.value   #   局部排序    
            node.right.value=tmpe
        if node.value<node.left.value:
            ccount+=1
            change=True
            tmpe=node.value 
            node.value=node.left.value   #   局部排序    
            node.left.value=tmpe
        if node.left.right!=None:
            if node.value<node.left.right.value:   #   跳出局部
                ccount+=1
                change=True
                tmpe=node.value 
                node.value=node.left.right.value   
                node.left.right.value=tmpe
        if node.right.left!=None:
            if node.value>node.right.left.value:   #   跳出局部
                ccount+=1
                change=True
                tmpe=node.value 
                node.value=node.right.left.value   
                node.right.left.value=tmpe
        
        
        cc,cg=paixu(node.left,ccount,change)
        return paixu(node.right,cc,cg)

root=Node(sortlist[0])
for i in sortlist[1:]:
    createTree(root,i)
print('初始化后的：',mbult(root))
print('原数据：',sortlist)

i=0
tiaojian=True
while tiaojian:
    i,tiaojian=paixu(root,i,False)
    
print('排序后的：',mbult(root))

结果为
初始化后的： [65, 6, 68, 72, 73, 4, 124, 81, 66]
原数据： [4, 72, 81, 6, 73, 124, 65, 68, 66]
排序后的： [4, 6, 65, 66, 68, 72, 73, 81, 124]

​

python实现AVL平衡二叉树的插入

insertlist=[5,72,78,1,77,2,656]

def treedree(tree):            #    返回树的深度
    if tree==None:
        return 0
    else :
        return max(treedree(tree.left)+1,treedree(tree.right)+1)
    

#
#       加入元素之后就需要往上 看哪个节点失衡    只要解决 这个失衡的节点就可以了   要由下至上不能由上至下

def lxuan(parent,sub):             #   左旋
    sub.parent=parent.parent
    if sub.parent!=None:
        if sub.parent.left==parent:
            sub.parent.left=sub
        else :
            sub.parent.right=sub
    parent.parent=sub
    if sub.left!=None:
        parent.right=sub.left
        sub.left.parent=parent
    else:
        parent.right=None
    sub.left=parent
def rxuan(parent,sub):             #   右旋
    sub.parent=parent.parent
    if sub.parent!=None:
        if sub.parent.left==parent:
            sub.parent.left=sub
        else :
            sub.parent.right=sub
    parent.parent=sub
    if sub.right!=None:
        parent.left=sub.right
        sub.right.parent=parent
    else:
        parent.left=None
    sub.right=parent
def avltree(tree,LorR=0):         #    平衡这棵树     从加入的节点往上遍历    所以传入的是加入节点   LorR -> -1  1
    #   如果左节点比右节点大 2   LL  LR   L
    #   如果有节点比左节点大 2   RR  RL   R
    #   于是往上去的时候要返回   左还是右
    #   平衡因子在这里就直接用深度比较代替
    
    info = treedree(tree.left)-treedree(tree.right)
    if info==2:
        if LorR==-1:         #     LL       一次右旋
            rxuan(tree,     tree.left)
            return True                        #   返回   True  代表改变过
        else:                #     LR       一次左旋加一次右旋
            lxuan(tree.left,  tree.left.right)
            rxuan(tree,  tree.left)
            return True
    elif info==-2:
        if LorR==-1:         #     RL       一次右旋加一次左旋
            rxuan(tree.right,  tree.right.left)
            lxuan(tree,  tree.right)
            return True
        else:                #     RR       一次左旋
            lxuan(tree,  tree.right)
            return True
    else :            #向上走
        if tree.parent==None:   #  到根节点了
            print('root')
            return False
        else:
            if tree==tree.parent.left:
                return avltree(tree.parent,-1)
            else :
                return avltree(tree.parent,1)
    
def pushvalue(tree,value):     #    二叉树中插入值
    if value<tree.value:
        if tree.left==None:
            tree.left=Node(value)
            tree.left.parent=tree
            avltree(tree.left)
        else:
            pushvalue(tree.left,value)
    else :
        if tree.right==None:
            tree.right=Node(value)
            tree.right.parent=tree
            avltree(tree.right)
        else:
            pushvalue(tree.right,value)

root=Node(sortlist[0])
for i in sortlist[1:]:
    createTree(root,i)
i=0
tiaojian=True
while tiaojian:
    i,tiaojian=paixu(root,i,False)
    
print('排序后的：',mbult(root))

print('插入前的：',mbult(root))
for i in insertlist:
    pushvalue(root,i)
print('插入后的：',mbult(root))

 

一只勇敢的小蚂蚁
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python之平衡二叉搜索树（AVL树）
夜空下的凝视
04-15 2028
平衡二叉搜索树（Balanced Binary Tree）： 是一种结构平衡的二叉搜索树，即叶节点高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。它能在O(log n)内完成插入、查找和删除操作，最早被发明的平衡二叉搜索树为AVL树。 常见的平衡二叉搜索树有：AVL树、红黑树、Treap、节点大小平衡树。 注意：移动树的节点时，被移动节点及其原新两个位置的父、子节点的指向均需重新指向，...
avl_tree:AVL树的python实现（自平衡二叉树）
07-02
avl_tree AVL树的python实现（自平衡二叉树） 描述： 这是具有以下外部方法的平衡二叉搜索树的实现： insert (data) 将数据插入树中，如果它尚未包含在树中insertList (list)通过迭代调用insert将list中的数据元素...
python平衡二叉排序树
sdhdsf132452的博客
04-15 185
话不多说，兄弟萌，show me the code! from chapter8.btSearch import DictBinTree from chapter8.Assoc import Assoc class BinTNode: """树节点类""" def __init__(self,dat,left=None,right=None): self.data = dat self.left = left self.right = r
python--数据结构--平衡二叉排序树
Chasing__Dreams的博客
08-23 489
平衡二叉排序树又称AVL树。 一棵平衡二叉排序树或者是空树，或者是具有下列性质的二叉排序树： 左子树与右子树的高度之差的绝对值小于等于1； 左子树和右子树也是平衡二叉排序树。 引入平衡二叉排序树的目的，是为了提高查找效率，其平均查找长度为O(log₂n)。 结点的平衡因子定义为：结点的左子树深度与右子树深度之差。显然，对一颗平衡二叉排序树而言，其所有结点的平衡因子只能是-1、0或1。当在一个平衡二叉排序树上插入一个结点时，可能导致失衡，即出现绝对值大于1的平衡因子，如2、-2。 一般情况下，只有新插入结
分步图解平衡二叉树的插入过程（Python实现）
u010483897的博客
02-11 248
下面这篇博主的介绍很不错，推荐： https://blog.csdn.net/qq_34840129/article/details/80728186
平衡二叉排序插入新节点后平衡调整
但行好事，莫问前程
03-26 589
LL（右单旋）插入根节点左孩子左子树 RR（左单旋）插入根节点右孩子右子树 LR（先左后右双旋转）插入根节点左孩子右子树 RL（先右后左双旋转）插入根节点右孩子左子树 以下来自王道： ...
权重平衡树的python实现
03-30
不同于AVL树（储存子树的高度）和红黑树（储存虚构的“颜色”位），加权平衡树储存记账信息的方式是对应用真正有用的属性：一棵树下元素的数量等于它的根的大小，然而这个根的大小是一个用来实现顺序统计树操作的...
平衡二叉树（AVL树）浅析
10-20
当插入或删除节点导致某个节点的平衡因子超过1时，需要进行相应的旋转操作来重新平衡树，主要有四种旋转：左旋、右旋、左右旋和右左旋。 1. 左旋（Left Rotation）：用于处理右子树过高的情况。旋转后，原节点的右...
Python实现二叉搜索树
09-21
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树数据...虽然在最坏的情况下，二叉搜索树的性能可能会退化成链表，但在平均情况下，其性能表现良好，且通过平衡技术（如AVL树或红黑树）可以进一步提高性能。
python实现二叉查找树实例代码
09-20
这个Python实现的二叉查找树能够完成基本的插入、查找和删除操作，适用于小规模数据的快速处理。然而，在大数据量的情况下，为了保持高效，可能需要考虑更高级的数据结构，如平衡二叉查找树（AVL树或红黑树）。平衡...
二叉搜索树、完全二叉树、平衡二叉树 Python实现
sinat_22510827的博客
05-17 618
1.二叉搜索树：若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。（即中序遍历情况下，值依次增大） # 二叉搜索树 # 中序遍历情况下，值递增则为二叉树 def isBSTree(head): minimum = -100000 # 设定一个最小值 ...
二叉树和排序二叉树 python实现
qq_41209110的博客
04-06 181
class Node: def __init__(self,item): self.item = item self.left = None self.right = None class Tree: def __init__(self): self.root = None def addNode(self,i...
【剑指offer】38.平衡二叉树[by Python]
qq_33487726的博客
06-28 187
题目描述 输入一棵二叉树，判断该二叉树是否是平衡二叉树。 解题方法 平衡二叉树的定义是任何节点的左右子树高度差都不超过1的二叉树。 按照定义，很容易得出获得左右子树高度，然后判断。递归写法。 Python代码： # -*- coding:utf-8 -*- # class TreeNode: # def __init__(self, x): # self.val = x ...
平衡二叉树：AVL树（python）
weixin_43786241的博客
10-22 370
        要了解平衡二叉树，先要知道什么是平衡因子。 平衡因子         平衡因子：左子树深度 – 右子树深度         如下面2幅图平衡因子分别为 -1、0                               &
平衡搜索二叉树的python实现
林贻民的博客
07-25 3023
我的代码片:https://code.csdn.net/snippets_manage# BST为二叉搜索树的实现文件 import BST''' 功能:往平衡二叉树中插入一个结点 参数: N:要插入的结点 ''' def BInsert(N): # 调用二叉树的插入函数插入元素 BST.Insert(N) # 找出刚插入的元素,更新结点的高
平衡二叉树(AVL)python代码实现，注释超级详细
geosipe的博客
04-27 2872
要了解AVL，就要先了解二叉排序树，二叉排序树（BST）的定义就是： 右子树的所有关键字均不小于根关键字的值。 若它的左子树不空，则左子树上的所有关键字的值均不大于根关键字的值。 若它的右子树不空，则右子树上的所有关键字的值均不小于根关键字的值。 左右子树又各是一颗二叉排序树 写者的二叉排序树基于里面的元素不重复。话不多说直接上代码 class BiTreeNode(object): # 先来定义一下树里面的节点 def __init__(self, data): sel
Python实现"平衡二叉树"的一种方法
qiubingcsdn的博客
09-04 1700
判断给定的二叉树是不是平衡二叉树 本文体中，高平衡二叉树定义为：二叉树中任意结点的左右子树深度差不超过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...
26. 平衡二叉排序树
热门推荐
dugudaibo的博客
03-05 2万+
平衡二叉排序树的生成，查找和删除
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、付费专栏及课程。

余额充值