Question

您好，我是OOP的新手，所以在您阅读本文时请记住这一点。

我有一个简单的Python树实现（参见下面的代码）。

class TreeNode(object):
    def __init__(self, data):
        self.data = data
        self.children = []

    def add_child(self, obj):
        self.children.append(obj)

class Tree:
    def __init__(self):
        self.root = TreeNode('ROOT')

    def preorder_trav(self, node):
        if node is not None:
            print node.data
            if len(node.children) == 0:
                print "("+ node.data + ")"
                for n in node.children:
                    self.preorder_trav(n)

if __name__ == '__main__':
    tr = Tree()
    n1 = tr.root
    n2 = TreeNode("B")
    n3 = TreeNode("C")
    n4 = TreeNode("D")
    n5 = TreeNode("E")
    n6 = TreeNode("F")

    n1.add_child(n2)
    n1.add_child(n3)
    n2.add_child(n4)
    n2.add_child(n5)
    n3.add_child(n6)

    tr.preorder_trav(n1)

我现在需要的是实现一个获取Leaf Nodes的方法。术语叶节点是指没有子节点的节点。

我想知道如何制作 get_leaf_nodes（）方法。

我想到了一些解决方案

在self.leaf_nodes = []方法中创建__init__。通过这个我知道它只会被这个树实例看到。
将班级成员leaf_nodes = []置于__init__方法之上。通过这个我知道所有树实例将能够看到leaf_nodes列表。

上述解决方案将使我在我的类中创建一个leaf_nodes列表，以便get_leaf_nodes()方法可以使用。我正在寻找的只是一个get_leaf_nodes()方法，它将在我的树上进行计算并返回一个列表。

例如在C中我们会调用malloc()然后我们可以返回指向调用get_leaf_nodes()的函数的指针。

Answer 1

在python中，您可以使用内部函数来收集叶节点，然后返回它们的列表。

def get_leaf_nodes(self):
    leafs = []
    def _get_leaf_nodes( node):
        if node is not None:
            if len(node.children) == 0:
                leafs.append(node)
            for n in node.children:
                _get_leaf_nodes(n)
    _get_leaf_nodes(self.root)
    return leafs

如果您想要更多 clean OOP方法，可以为叶子集合创建额外的私有方法：

def get_leaf_nodes(self):
    leafs = []
    self._collect_leaf_nodes(self.root,leafs)
    return leafs

def _collect_leaf_nodes(self, node, leafs):
    if node is not None:
        if len(node.children) == 0:
            leafs.append(node)
        for n in node.children:
            self._collect_leaf_nodes(n, leafs)

这就是我用Java做的方式。

Answer 2

这个方法应该足以让叶子可以从任何节点到达，如果你用树的根调用它，你将获得树的所有叶子：

def get_leaves(node):
    if not node.children:
        yield node

    for child in node.children:
        for leaf in get_leaves(child):
             yield leaf

Answer 3

找到树叶的一种很好的递归方法。

def leaf_count(self):

        if(self == None):
            return 0

        if(self.left == None or self.right == None):
            return 1

        return self.left.leaf_count() + self.right.leaf_count()

Answer 4

我认为以前的贡献者已经正确回答了这个问题，但是没有人真正展示如何设置节点并将这些值添加到树中，然后运行它以证明它实际上可以一起工作。这就是为什么我要回答这个问题：

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


class Pattern():
    def getLeafs(self,root):
        if not root: 
            return []
        if not root.left and not root.right: 
            return [root.val]
        leaves = self.getLeafs(root.left) + self.getLeafs(root.right)
        return leaves 

    def similar_leaf(self, root1, root2):
        return self.getLeafs(root1) == self.getLeafs(root2)


#simple test 
root= Node(3)
root.left = Node(5)
root.right= Node(1)

root.left.left =  Node(6)
root.left.right =  Node(2)
root.left.right.left =Node(7)
root.left.right.right =Node(4)

root.right.left =  Node(9)
root.right.right =  Node(8)

pattern =Pattern()
print(pattern.similar_leaf(root,root))

如何使用Python获取树的叶节点？

4 个答案: