Question

我正在处理一个trie数据结构，其中每个节点都是一个列表，其中包含一个值和一个对应于该值的子节点的引用，但看起来列表中的引用没有被分开来自彼此 - 例如，如果＆＃34;＆＃34;＆＃34;和＆＃34;罪恶＆＃34;在我的CONTAINS（）函数中都会返回true，因为＆＃34;她＆＃34;因为＆＃39; s＆＃39;是第一级，＆＃39; h＆＃39;在第二级，并且＆＃39; e＆＃39;即使这些字符应该在不同的分支中，也在第三级。我读过有关python引用的内容，无法弄清楚为什么会这样。

class triepair:
    value = None
    next = None

    def __init__(self, value=None, next=None):
        self.value = value
        self.next = next

    def NEXT(self,next):
        self.next = next

    def GETNEXT(self):
        return self.next

class trienode:
    nodespace = []

    def __int__(self,nodespace=[]):
        self.nodespace = nodespace

    def APPEND(self,value):
        newnext = trienode()
        newpair = triepair(value,newnext)
        self.nodespace.append(newpair)

    def NEXT(self, value):
        for triepair in self.nodespace:
            if triepair.value == value:
                return triepair.GETNEXT()

        print("ERROR: value not found")
        return None

    def CONTAINS(self, value):
        for triepair in self.nodespace:
            if triepair.value == value:
                return True

        return False

    def INSERT(self, word):
        c = word[:1]
        rest = word[1:]

        if self.CONTAINS(c):
            if len(rest) > 0:
                nextnode = self.NEXT(c)
                nextnode.INSERT(rest)

        else:
            self.APPEND(c)
            if len(rest) > 0:
                nextnode = self.NEXT(c)
                nextnode.INSERT(rest)


    def TRACE(self, word):
        c = word[:1]
        rest = word[1:]
        if self.CONTAINS(c):
            print "found character ",c
            if self.NEXT(c) is not None and len(rest) > 0:
                self.NEXT(c).TRACE(rest)
            else:
                print "trace complete"

    def HASWORD(self, word):
        c = word[:1]
        rest = word[1:]

        if self.CONTAINS(c):
            #print str(self)," contains ",c
            if len(rest) > 0:
                return self.NEXT(c).HASWORD(rest)
            else:
                return True

        else:
            return False

class trie:
    root = trienode()

    def __init__(self):
        self.root = trienode()

    def INSERT(self,word):
        self.root.INSERT(word)

    def TRACE(self,word):
        if self.root is not None:
            self.root.TRACE(word)
        else:
            print("null trie")

    def CONTAINS(self, word):
        return self.root.HASWORD(word)

Answer 1

大笑，这花了我一段时间来调试，但我找到了它。

改变这个：

class trienode:
    nodespace = []

    def __int__(self,nodespace=[]):
        self.nodespace = nodespace

对此：

class trienode:
    nodespace = []

    def __init__(self):
        self.nodespace = []

首先，__int__不是一件事，但这只是问题的一部分。

在不知道为什么的完整Pythonic详细信息的情况下，根nodespace被重新使用。

因此，当您在APPEND()中创建一个新的时，它实际上并没有发生，并且您在新的“子”中获得相同的nodespace。

结果，一切都很平淡。所有value -> trienode对都处于同一级别，并且trienode引用始终是相同的。

无论如何，通过上述更改，您确保以新的空nodespace开头，因此APPEND()和.NEXT().CONTAINS()等会更像您期望的那样

如何分离列表中节点的子节点

1 个答案: