正确使用扩展？答案

【问题标题】：Using extend correctly?正确使用扩展？
【发布时间】：2013-03-07 05:28:52
【问题描述】：

class BTNode(object):
"""A node in a binary tree."""

def __init__(self, item, left=None, right=None):
    """(BTNode, object, BTNode, BTNode) -> NoneType
    Initialize this node to store item and have children left and right,
    as well as depth 0.
    """
    self.item = item
    self.left = left
    self.right = right
    self.depth = 0  # the depth of this node in a tree

def __str__(self):
    """(BTNode) -> str
    Return a "sideways" representation of the subtree rooted at this node,
    with right subtrees above parents above left subtrees and each node on
    its own line, preceded by as many TAB characters as the node's depth.
    """
    # If there is a right subtree, add an extra TAB character in front of
    # every node in its string representation, with an extra newline at the
    # end (ready to be concatenated with self.item).
    if self.right:
        str_right = "\t" + str(self.right).replace("\n", "\n\t") + "\n"
    else:
        str_right = ""
    # The string representation of self.item: if item is a string, use
    # repr(item) so that quotes are included and special characters are
    # treated correctly -- just like in a list; else use str(item).
    if isinstance(self.item, str):
        str_item = repr(self.item)
    else:
        str_item = str(self.item)
    # If there is a left subtree, add an extra TAB character in front of
    # every node in its string representation, with an extra newline at the
    # beginning (ready to be concatenated with self.item).
    if self.left:
        str_left = "\n\t" + str(self.left).replace("\n", "\n\t")
    else:
        str_left = ""
    # Put the right subtree above the root above the left subtree.
    return str_right + str_item + str_left

def leaves_and_internals(self):
    """(BTNode) -> ([object], [object])
    Return a pair of lists: (list of all the items stored in the leaves of
    the subtree rooted at this node, list of all the items stored in the
    internal nodes of the subtree rooted at this node).
    """
    #Leaf: Doesn't have children
    #Internal Node: Has children
    leaf = []
    internal = []
    if not self.left and not self.right:
        leaf.append(self.item)
    if self.left is not None:
        internal.append(self.item)
        if self.right is not None:
            self.right.leaves_and_internals()
        self.left.leaves_and_internals()
    elif self.right is not None:
        internal.append(self.item)
        self.right.leaves_and_internals()
    print(leaf, internal)
    return leaf, internal

BTNode 类是提供给我们的起始代码，我们无法对其进行编辑。我的职责是按照给定的文档字符串为leaves_and_intervals 编写代码。我目前唯一的问题是不知道如何使用 extend 以递归方式正确组合列表。

我的测试块是这样的：

if __name__ == "__main__":
    root = BTNode(2, BTNode(4, BTNode(6, BTNode(8, None, None), None), None), None)
    root.leaves_and_internals()

我的输出看起来像这样：

[8] []
[] [6]
[] [4]
[] [2]

正确的输出应该是这样的（顺序无关紧要）：

[8] [6, 4, 2]

我如何正确使用扩展，以便叶子和内部不会在每次递归时都重置回空列表？我知道我必须有第二组扩展列表，只是不确定如何实现它。

【问题讨论】：

如果您将失败的尝试包含在使用extend 中会更好，并将问题缩小到一个简单的示例。通常情况下，仅此一项就可以帮助您找到解决方案。

标签： python list tree extend

【解决方案1】：

如果你想递归解决这个问题，你不需要显式声明空列表。只需汇总每个子问题的结果。

这是我的方法：

def leaves_and_internals(self): 
    if not self.left and not self.right:
        #leaf.append(self.item)
        return ([], [self.item])
    if self.left is not None:
        #internal.append(self.item)
        if self.right is not None:
            #return ([self.item], []) + self.right.leaves_and_internals()
            return tuple(map(operator.add,([self.item], []), self.right.leaves_and_internals()))
        #return ( [self.item], []) + self.left.leaves_and_internals()
        return tuple( map(operator.add, ([self.item], []), self.left.leaves_and_internals()))
    elif self.right is not None:
        #internal.append(self.item)
        #(leaf, internal) + self.right.leaves_and_internals()
        #return ( [self.item], []) + self.right.leaves_and_internals()
        return tuple(map(operator.add,([self.item], []), self.right.leaves_and_internals()))

【讨论】：

【解决方案2】：

我看到您的代码几乎具有正确的逻辑。这是我的实现。

def leaves_and_internals(self):
    leaves    = []
    internals = []

    if self.left or self.right:
        internals.append(self.item)
    else:
        leaves.append(self.item)

    if self.left:
        sub_leaves, sub_internals = self.left.leaves_and_internals()
        leaves.extend(sub_leaves)
        internals.extend(sub_internals)

    if self.right:
        sub_leaves, sub_internals = self.right.leaves_and_internals()
        leaves.extend(sub_leaves)
        internals.extend(sub_internals)

    return leaves, internals

【讨论】：