python中的遞歸和返回語句

Question

我正在嘗試實現2-3棵樹，但是在find方法上遇到了麻煩。 給定int作為參數的此方法應返回包含int的節點。 問題在於有時它可以工作，有時卻不能，我也不知道為什么。 我添加了測試打印。 對於我肯定知道屬於樹的一部分的特定int，代碼將執行print語句，這意味着它已找到該節點，但未返回此節點。 而是返回在代碼末尾的False。

你能幫我解決這個問題嗎？

def find(self,data,node=0): #return problem ???

    if node==0:
        a=self.root
    else:
        a=node

    if a.data2==None:
        if data==a.data:   ### here is the problem
            print("qwertyuiop") ### it does not execute the return statement
            return a
        elif data < a.data:
            if a.left!=None:
                return self.find(data,a.left)
        elif data > a.data:
            if a.right!=None:
                return self.find(data,a.right)

    else:
        if a.data2!=None:
                if (data==a.data or data==a.data2):
                    return a
                elif data<a.data:
                    if a.left!=None:
                        return self.find(data,a.left)
                elif (data>a.data and data<a.data2):
                    if a.middle!=None:
                        return self.find(data,a.middle)
                elif data>a.data2:
                    if a.right!=None:
                        return self.find(data,a.right)
    print("Not Found") ### function executes this print
    return False

self.root是樹的根，並且是以下類的對象

class Node:

    def __init__(self, data=None, left=None, right=None):
        self.data = data
        self.data2 = None
        self.data3 = None
        self.left = left
        self.right = right
        self.middle = None
        self.middle2 = None

二進制搜索樹：

class Nodeee:

def __init__(self, data=None, left=None, right=None):
    self.data = data
    self.left = left
    self.right = right

class BST:


def __init__(self, root=None):
    self.c=[]
    self.total=0
    self.root = None


def parent(self,data,node=5):

    def search(nodee,cc,data):

        if data==cc.data:
            return nodee
        else:
            if data<cc.data:
                nodee=cc
                return search(nodee,cc.left,data)
            elif data>cc.data:
                nodee=cc
                return search(nodee,cc.right,data)

        print("Parent Error")
        return False

    if node==self.root:
        print("Root has no parent")
    else:
        a=self.root
        c=self.root
        return search(a,c,data)


def lookup(self,data,node=0):

    if node==0:
        a=self.root
    else:
        a=node

    if data < a.data:
        if a.left==None:
            return a
        else:
            return self.lookup(data,a.left)
    elif data > a.data:
        if a.right==None:
            return a
        else:
            return self.lookup(data,a.right)

def find(self,data,node=0):

    if node==0:
        a=self.root
    else:
        a=node

    if data==a.data:
        print("WTF")
        return a
    elif data < a.data:
        if a.left!=None:
            return self.find(data,a.left)
    elif data > a.data:
        if a.right!=None:
            return self.find(data,a.right)
    print("Not Found")
    return False

def find2(self,data,node=0):

    if node==0:
        a=self.root
    else:
        a=node

    if data==a.data:
        return True
    elif data < a.data:
        return self.find2(data,a.left)
    elif data > a.data:
        return self.find2(data,a.right)
    return False

def is_empty(self):
    if self.root==None:
        return True


def is_leaf(self,n):
    if (n.left==None and n.right==None):
        return True
    return False

def delete(self):
    self.root=None

def insert(self, data):

    if self.root==None:
        self.root=Nodeee(data)
        self.total+=1
        return True
    else:
        b=self.lookup(data)
        if data < b.data:
            b.left=Nodeee(data)
            self.total+=1
            return True
        elif data > b.data:
            b.right=Nodeee(data)
            self.total+=1
            return True
    print("Insert Error !")
    return False


def inorder_swap(self,data):
    a=self.find(data)
    b=a.right
    while self.is_leaf(b)!=True:
        if b.left!=None:
            b=b.left
        elif b.left==None:
            b=b.right
    temp=a.data
    a.data=b.data
    b.data=temp

def remove(self,data):
    a=self.find(data)
    if self.is_leaf(a)==True:
        b=self.parent(data)
        if b.left==a:
            b.left=None
        elif b.right==a:
            b.right=None
    elif self.is_leaf(a)==False:
        if a.left==None:
            b=self.parent(data)
            if b.left==a:
                b.left=b.left.right
            elif b.right==a:
                b.right=b.right.right
        elif a.right==None:
            b=self.parent(data)
            if b.left==a:
                b.left=b.left.left
            elif b.right==a:
                b.right=b.right.left
        elif (a.left!=None and a.right!=None):
            self.inorder_swap(data)
            self.remove(data)

def inorder(self,node):
    if node!=None:
        self.inorder(node.left)
        self.c.append(node.data)
        self.inorder(node.right)

def inorder_print(self):
    self.c=[]
    self.inorder(self.root)
    print("\nStart")
    for x in range(len(self.c)):
            print(self.c[x], end=",")
    print("\nFinish\n")




a=BST()
print(a.insert(234)==True)
print(a.insert(13)==True)
print(a.insert(65)==True)
print(a.insert(658)==True)
print(a.insert(324)==True)
print(a.insert(86)==True)
print(a.insert(5)==True)
print(a.insert(76)==True)
print(a.insert(144)==True)
print(a.insert(546)==True)
print(a.insert(2344)==True)
print(a.insert(1213)==True)
print(a.insert(6345)==True)
print(a.insert(653348)==True)
print(a.insert(35324)==True)
print(a.insert(8463)==True)
print(a.insert(5555)==True)
print(a.insert(76539)==True)
print(a.insert(14499)==True)
print(a.insert(59999946)==True)

a.inorder_print()
a.remove(35324)
a.remove(1213)
a.remove(2344)
a.remove(144)
a.remove(5555)
a.remove(6345)
a.remove(59999946)
a.remove(76)
print(a.root.data)
a.inorder_print()

Answer 1

def inorder_swap(self,data):
    a=self.find(data)
    b=a.right
    while self.is_leaf(b)!=True:
        if b.left!=None:
            b=b.left
        elif b.left==None:
            b=b.right
    temp=a.data
    a.data=b.data
    b.data=temp

a在這里是包含通過節點data 。 這種方法確實沒有什么比別人換a的data與一些葉子的data （第一個同時發現），從而扭曲的樹順序。 因此，對相同data后續find失敗，並返回False 。 由於您的代碼沒有錯誤檢查，因此會導致AttributeError 。

您可能想在inorder_swap移動節點。 但是，您只能分配給本地名稱b 。 如果要更改節點，則需要使用b.left =或b.right = 。

可能還有更多問題，我現在看不到。

另外，您的代碼也有幾個樣式問題，其中一些：

1. 您具有四個相同的功能： find ， find2 ， lookup和search in parent 。

2. 大部分的命名都不會提供信息，甚至不會引起混淆。

3. 像if a.right==None:應該寫成if not a.right:或者if a.right is None: 。

4. 檢查函數的返回值，不要僅僅假設它們可能不會返回有效的節點（即find可能返回False而不是節點）。 或者使用異常處理。

5. 如果您有一個if ... elif ... elif塊，則不必檢查最后一種可能性是否確定為真，例如：

     if b.left!=None: # something elif b.left==None: # something else 

   應該

     if b.left: # something else: # something else