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的{{1}}与一些叶子data（找到的第一个）交换时，除了扭曲树顺序之外别无其他。因此，同一data上的后续find会失败并返回data。由于您的代码没有错误检查，因此会生成False。

您可能希望在AttributeError中移动节点。但是，您只需指定本地名称inorder_swap。如果您想更改节点，则需要使用b或b.left =。

可能有更多问题，我现在还没有看到。

此外，您的代码有几个样式问题，其中一些：

您有四个功能相同：b.right =中的find，find2，lookup和search。
大部分命名都没有提供信息，甚至不会引起混淆。
parent之类的行应该写成if a.right==None:（或者if not a.right:）。
检查函数的返回值，并且不要假设它们返回有效节点（如果它们可能没有）（即if a.right is None:可能返回find而不是节点）。或者使用异常处理。

如果您有False块，则无需检查最后一种可能性，例如：

if ... elif ... elif

应该是

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

python中的递归和返回语句

1 个答案: