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. 在parent 中有四个函数：find、find2、lookup 和 search。

2. 大多数命名都没有提供信息，甚至令人困惑。

3. 像if a.right==None: 这样的行应该写成if not a.right:（或者if a.right is None:）。

1234563或者使用异常处理。

4. 如果你有一个if ... elif ... elif 块，你不必检查最后一种可能性，如果它确定是真的，例如：

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

   应该是

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