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

下面是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))