Python 如何分别打印叶节点和非叶节点

我想从给定的代码中分别打印非叶节点和叶节点。如果有人能帮上忙，那就太好了

这是我的密码： def调试（msg）： 如果输出调试： 打印（msg）

类节点（）： definit（自身，键）： self.key=key self.left=无 self.right=无

类AVLTree（）： definit（self，*args）： self.node=None self.height=-1
自平衡=0

    if len(args) == 1: 
        for i in args[0]: 
            self.insert(i)
            
def height(self):
    if self.node: 
        return self.node.height 
    else: 
        return 0 

def is_leaf(self):
    return (self.height == 0)
    

def insert(self, key):
    tree = self.node
    
    newnode = Node(key)
    
    if tree == None:
        self.node = newnode 
        self.node.left = AVLTree() 
        self.node.right = AVLTree()
        debug("Inserted key [" + str(key) + "]")
    
    elif key < tree.key:  
        self.node.left.insert(key)
        
    elif key > tree.key: 
        self.node.right.insert(key)
    
    else: 
        debug("Key [" + str(key) + "] already in tree.")
        
    self.rebalance() 
    
def rebalance(self):
    ''' 
    Rebalance a particular (sub)tree
    ''' 
    # key inserted. Let's check if we're balanced
    self.update_heights(False)
    self.update_balances(False)
    while self.balance < -1 or self.balance > 1: 
        if self.balance > 1:
            if self.node.left.balance < 0:  
                self.node.left.lrotate() # we're in case II
                self.update_heights()
                self.update_balances()
            self.rrotate()
            self.update_heights()
            self.update_balances()
            
        if self.balance < -1:
            if self.node.right.balance > 0:  
                self.node.right.rrotate() # we're in case III
                self.update_heights()
                self.update_balances()
            self.lrotate()
            self.update_heights()
            self.update_balances()


        
def rrotate(self):
    # Rotate left pivoting on self
    debug ('Rotating ' + str(self.node.key) + ' right') 
    A = self.node 
    B = self.node.left.node 
    T = B.right.node 
    
    self.node = B 
    B.right.node = A 
    A.left.node = T 


def lrotate(self):
    # Rotate left pivoting on self
    debug ('Rotating ' + str(self.node.key) + ' left') 
    A = self.node 
    B = self.node.right.node 
    T = B.left.node 
    
    self.node = B 
    B.left.node = A 
    A.right.node = T 
    
        
def update_heights(self, recurse=True):
    if not self.node == None: 
        if recurse: 
            if self.node.left != None: 
                self.node.left.update_heights()
            if self.node.right != None:
                self.node.right.update_heights()
        
        self.height = max(self.node.left.height,
                          self.node.right.height) + 1 
    else: 
        self.height = -1 
        
def update_balances(self, recurse=True):
    if not self.node == None: 
        if recurse: 
            if self.node.left != None: 
                self.node.left.update_balances()
            if self.node.right != None:
                self.node.right.update_balances()

        self.balance = self.node.left.height - self.node.right.height 
    else: 
        self.balance = 0


        
def delete(self, key):
    # debug("Trying to delete at node: " + str(self.node.key))
    if self.node != None: 
        if self.node.key == key: 
            debug("Deleting ... " + str(key))  
            if self.node.left.node == None and self.node.right.node == None:
                self.node = None # leaves can be killed at will 
            # if only one subtree, take that 
            elif self.node.left.node == None: 
                self.node = self.node.right.node
            elif self.node.right.node == None: 
                self.node = self.node.left.node
            
            # worst-case: both children present. Find logical successor
            else:  
                replacement = self.logical_successor(self.node)
                if replacement != None: # sanity check 
                    debug("Found replacement for " + str(key) + " -> " + str(replacement.key))  
                    self.node.key = replacement.key 
                    
                    # replaced. Now delete the key from right child 
                    self.node.right.delete(replacement.key)
                
            self.rebalance()
            return  
        elif key < self.node.key: 
            self.node.left.delete(key)  
        elif key > self.node.key: 
            self.node.right.delete(key)
                    
        self.rebalance()
    else: 
        return 


def logical_predecessor(self, node):
    ''' 
    Find the biggest valued node in LEFT child
    ''' 
    node = node.left.node 
    if node != None: 
        while node.right != None:
            if node.right.node == None: 
                return node 
            else: 
                node = node.right.node  
    return node 

def logical_successor(self, node):
    ''' 
    Find the smallese valued node in RIGHT child
    ''' 
    node = node.right.node  
    if node != None: # just a sanity check  
        
        while node.left != None:
            debug("LS: traversing: " + str(node.key))
            if node.left.node == None: 
                return node 
            else: 
                node = node.left.node  
    return node 

def check_balanced(self):
    if self == None or self.node == None: 
        return True
    
    # We always need to make sure we are balanced 
    self.update_heights()
    self.update_balances()
    return ((abs(self.balance) < 2) and self.node.left.check_balanced() and self.node.right.check_balanced())  
    
def inorder_traverse(self):
    if self.node == None:
        return [] 
    
    inlist = [] 
    l = self.node.left.inorder_traverse()
    for i in l: 
        inlist.append(i) 

    inlist.append(self.node.key)

    l = self.node.right.inorder_traverse()
    for i in l: 
        inlist.append(i) 

    return inlist


def display(self, level=0, pref=''):
    '''
    Display the whole tree (but turned 90 degrees counter-clockwisely). Uses recursive def.
    '''        
    self.update_heights()  # Must update heights before balances 
    self.update_balances()  
    if(self.node != None): 
        print ('-' * level * 2, pref, self.node.key, "[" + str(self.height) + ":" + str(self.balance) + "]", 'Leaf' if self.is_leaf() else 'non-leaf ')    
        if self.node.left != None: 
            self.node.left.display(level + 1, '<')
        if self.node.left != None:
            self.node.right.display(level + 1, '>')

      





     

 

如果len（args）==1：
对于args[0]中的i：
自我介绍.插入（i）
def高度（自身）：
如果self.node：
返回self.node.height
其他：
返回0
def是_叶（自身）：
返回值（self.height==0）
def插入（自，钥匙）：
tree=self.node
newnode=节点（键）
如果树==无：
self.node=newnode
self.node.left=AVLTree（）
self.node.right=AVLTree（）
调试（“插入的键[“+str（键）+”]”）
elif keytree.key：
self.node.right.insert（键）
其他：
调试（“键[“+str（键）+”]已在树中。”）
自我再平衡
def再平衡（自我）：
''' 
重新平衡特定（子）树
''' 
#钥匙插入。让我们看看我们是否平衡
自我更新高度（错误）
自我更新余额（假）
当self.balance<-1或self.balance>1时：
如果self.balance>1：
如果self.node.left.balance<0：
self.node.left.lrotate（）#我们在案例二
self.update_heights（）
self.update_余额（）
self.rrotate（）
self.update_heights（）
self.update_余额（）
如果自平衡<-1：
如果self.node.right.balance>0：
self.node.right.rrotate（）#我们在案例三
self.update_heights（）
self.update_余额（）
self.lrotate（）
self.update_heights（）
self.update_余额（）
def rrotate（自）：
#以自身为轴向左旋转
调试（'Rotating'+str（self.node.key）+'right'）
A=自组织节点
B=self.node.left.node
T=B.right.node
self.node=B
B.right.node=A
A.left.node=T
def L旋转（自）：
#以自身为轴向左旋转
调试（'旋转'+str（self.node.key）+'左'）
A=自组织节点
B=self.node.right.node
T=B.left.node
self.node=B
B.left.node=A
A.right.node=T
def更新高度（自，递归=真）：
如果不是self.node==无：
如果再次发生：
如果self.node.left！=无：
self.node.left.update_heights（）
如果self.node.right！=无：
self.node.right.update_heights（）
self.height=max（self.node.left.height，
self.node.right.height）+1
其他：
self.height=-1
def update_余额（self，recurse=True）：
如果不是self.node==无：
如果再次发生：
如果self.node.left！=无：
self.node.left.update_balances（）
如果self.node.right！=无：
self.node.right.update_balances（）
self.balance=self.node.left.height-self.node.right.height
其他：
自平衡=0
def delete（自我，密钥）：
#调试（“尝试在节点处删除：+str（self.node.key））
如果self.node！=无：
如果self.node.key==键：
调试（“删除…”+str（键））
如果self.node.left.node==None和self.node.right.node==None：
self.node=None#可以随意杀死树叶
#如果只有一棵子树，就拿它来说吧
elif self.node.left.node==无：
self.node=self.node.right.node
elif self.node.right.node==无：
self.node=self.node.left.node
#最坏情况：两个孩子都在场。查找逻辑后继者
其他：
替换=self.logical_后继（self.node）
如果更换！=无：#健康检查
调试（“找到了“+str（key）+”->“+str（replacement.key）”的替换项”）
self.node.key=replacement.key
#替换。现在从右子项中删除密钥
self.node.right.delete（replacement.key）
自我再平衡
返回
elif keyself.node.key：
self.node.right.delete（键）
自我再平衡
其他：
返回
def逻辑_前置程序（自身、节点）：
''' 
在左子节点中查找值最大的节点
''' 
node=node.left.node
如果节点！=无：
而node.right！=无：
如果node.right.node==无：
返回节点
其他：
node=node.right.node
返回节点
def逻辑_后继（自身，节点）：
''' 
在右侧子节点中查找smallese值节点
''' 
node=node.right.node
如果节点！=无：#只是一次精神检查
而node.left！=无：
调试（“LS:遍历：+str（node.key））
如果node.left.node==无：
返回节点
其他：
node=node.left.node
返回节点
def检查_平衡（自）：
如果self==无或self.node==无：
返回真值
#我们总是需要确保我们是平衡的
self.update_heights（）
self.update_余额（）
return（（abs（self.balance）<2）和self.node.left.check_balanced（）和self.node.right.check_balanced（））
按顺序遍历的定义（自）：
如果self.node==无：
返回[]
inlist=[]
L