0

我正在尝试实现树结构，但是当我尝试在树中打印数据时，会显示意外结果。

正确的结果将是：

root
 - A1
-- A2
--- A3
---- A4
----- A5

但我得到了：

root
 - A1
-- A1
--- A2
~ infinite loop

我的代码有什么问题？你可以回答我吗？

#!/usr/bin/python
class TreeNode :
    def __init__(self,key,obj=dict()) :
        print 'Node with '+key+' is created'
        self.key=key
        self.child=obj
    def add_child(self, key, obj) :
        self.child[key]=obj
        print 'child len ',
        print len(self.child)
    def get_child(self) :
        for key in self.child.keys() : 
            print key,
            pass
        print ''
        return self.child
    def find_child(self,key) :
        return self.child[key]
    def is_leap(self) : 
        print 'is_leap ',
        print len(self.child)
        if len(self.child)==0 :
            return 1
        else : return 0
    def append_rec(self,hier,data,depth) :
        # hier & data are lists
        if len(hier)== 1 : 
            print 'end of hierachy. append complete @ depth ',
            print depth
            return

        tmp = hier[0]
        tmp_child = hier[1:]
        name = str(hier[0])
        print 'self ',
        print tmp,
        print 'childs ',
        print tmp_child
        child_list = self.get_child()
        if child_list != None :
            if not name in child_list.keys() :  
                lc = TreeNode(name)
                self.add_child(name,lc)
                return lc.append_rec(hier[1:],data,depth+1)
            else :
                lc =child_list[name]
                return lc.append_rec(hier[1:],data,depth+1)
    def print_all(self,depth) :
        for i in range(depth) : print '-', 
        print self.key
        if len(self.child) == 0 : return
        if depth > 10 : 
            print 'depth limit over'
            return
        else :
            for k in self.child.keys() : 
                print 'Looking child having key = '+k
                return (self.child[k]).print_all(depth+1)




    # recursive method
class Tree :
    index = 0
    # root node of tree
    def __init__(self) :
        self.root=TreeNode('root')
        self.index=0
    def get_child(self) :
        return self.root.get_child()  
    def print_all(self) :
        self.root.print_all(0)
    def traverse(self) :
        node=self.root
        depth=0

        childs = node.get_child()
        if node.is_leap() : return
        else :
            for c in childs.keys() :
                print c,
                return self.traverse_rec(childs[c],depth+1)
        print ' end'

    def traverse_rec(self,node,depth) :
        i=0
        print 'depth ',
        print i,
        childs = node.get_child()
        if node.is_leap() : return
        else :
            for c in childs.keys() :
                print c,
                return self.traverse_rec(childs[c],depth+1)
        print ' end'


    def append(self,tup) :
        # root
        tmp = tup[0].split('/')
        data = tup[1]
        print 'root ['+data+']',
        tmp_child = tmp[1:]
        name = str(tmp[0])
        # if treenode with name tmp[0]
        child_list = self.root.get_child()
        if child_list != None :
            if not name in child_list.keys() :  
                #print 'name = '+name
                lc = TreeNode(name)
                self.root.add_child(name,lc)
                lc.append_rec(tmp_child,data,1)
            else :
                lc=child_list[name]
                lc.append_rec(tmp_child,data,1)


tree = Tree()
test_string = ('A1/A2/A3/A4/A5','example1')
tree.append(test_string)
tree.print_all()
4

1 回答 1

1

在 Python 中，默认参数只计算一次。所以每次你创建一个TreeNode没有显式obj参数的，它都会被分配给同一个字典。

解决这个问题的一种方法是使用 None 作为默认参数，就像这样。

def __init__(self,key,obj=None) :
    print 'Node with '+key+' is created'
    self.key=key
    self.child=obj if obj is not None else {}

另一种选择是进行防御性副本。如果您不希望通过引用不小心将字典传递给它，这将有所帮助，尽管这意味着它可能会掩盖其他错误。另请注意，这只会进行浅拷贝，这通常是您想要的，但并非总是如此。

def __init__(self,key,obj=dict()) :
    print 'Node with '+key+' is created'
    self.key=key
    self.child=obj.copy()
于 2013-03-10T05:29:38.947 回答