Question

class BST:

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

    def __str__(self):
        return "[%s, %s, %s]" % (self.left, str(self.val), self.right)

    def insert(self, val):
        if self.isEmpty():
            self.val = val
        elif val < self.val:
            if self.left is None:
                self.left = BST(val)
            else:
                self.left.insert(val)
        else:
            if self.right is None:
                self.right = BST(val)
            else:
                self.right.insert(val)

    def printpath(self,val,path):
        if self.val == val:
            return path
        if self.val > val:
            self.left.printpath(val,path)
        else:
            self.right.printpath(val,path)
        path.append(self.val)


a = BST(4)
a.insert(2)
a.insert(3)
a.insert(5)
a.insert(1)
a.insert(7)
a.insert(6)
a.insert(0)
print a

s = 0
d = 6
lpath = []
rpath = []
lpath.append(s)
a.printpath(s,lpath)
a.printpath(d,rpath)
rpath.reverse()
rpath.append(d)
print lpath,rpath

Answer 1

你要做的是找到从根节点到源节点和目标节点顶部的路径，然后连接两者（以正确的方式，即通过反转其中一条路径）。

如果树是平衡的（很可能与你的代码不一致），那么这将是O（log n）并且很难被击败。

我唯一能解决的问题是你的路径可能会不必要地长。例如，请选择以下树：

如果您正在搜索从1到3的路径，您的代码将返回1,2,4,4,2,3。此路径实际上可以缩短为1,2,3。为了解决这个问题，您可以首先计算路径的两个部分，然后查看它们的结束。虽然两端是相同的，但缩短了两个部分。最后，不要忘记包含最后删除的元素（但只包括一次）。

如果您想让代码更快，您可以逐步创建路径的两个部分，并在它们相遇时停止。但这样做会使你的代码变得更复杂（它需要使用类似哈希集的东西，或者甚至更好地存储每个节点中的深度），以便最有可能不会显着提高性能。

任何人都可以为下面的代码提供更好的解决方案，以便在BST中查找从源节点到目标节点的路径吗？

1 个答案: