Question

例如，像这样的树：

print(tree.branchLenSum())

将是1+1+2+2=6

树类：

class BinaryTree:

    # Constructor, takes in new key value
    def __init__(self, myKey):
        self.key = myKey
        self.leftChild = None
        self.rightChild = None

    # Returns root key value
    def getRootValue(self):
        return self.key

    # Changes root key value
    def setRootValue(self, newKey):
        self.key = newKey

    # Returns reference to left child
    def getLeftChild(self):
        value=None
        if self.leftChild!=None:
            value=self.leftChild
        return value

    # Returns reference to right child
    def getRightChild(self):
        value=None
        if self.rightChild!=None:
            value = self.rightChild
        return value

    def insertLeftChild(self, childKey):
        newNode = BinaryTree(childKey)
        newNode.leftChild = self.leftChild
        self.leftChild = newNode

    # Inserts key as right child. Existing right child becomes new right child
    # of new key
    def insertRightChild(self, childKey):
        newNode = BinaryTree(childKey)
        newNode.rightChild = self.rightChild
        self.rightChild = newNode

我为这个例子建立的树：

tree=BinaryTree(5)
tree.insertLeftChild(3)
tree.insertRightChild(6)
nodeA=tree.getLeftChild()
nodeA.insertLeftChild(7)
nodeA.insertRightChild(2)

到目前为止我所拥有的：

def branchLenSum(self):
    rounds=0
    if self.getLeftChild() ==None and self.getRightChild()==None:
        return rounds+rounds+1
    else:
        rounds+=rounds+1
        if self.getLeftChild()!=None:
            rounds+=self.getLeftChild().branchLenSum()
        if self.getRightChild()!=None:
            rounds+=self.getRightChild().branchLenSum()
        return rounds

我的想法是，每次前往下一个节点，计数器都会增加1 +计数器本身。我认为这将得到所有长度的总和。

Answer 1

好的，所以你只得到5的结果的原因很简单：你正在做的是计算节点。所以在你的情况下，你有5个节点，所以结果是5。

如果你想获得内部路径长度，那么我相信你必须在浏览树时跟踪当前的深度。您只需使用可选参数即可完成此操作。

def branchLenSum(self, depth = 0):
    rounds = depth
    if self.leftChild:
        rounds += self.leftChild.branchLenSum(depth + 1)
    if self.rightChild:
        rounds += self.rightChild.branchLenSum(depth + 1)
    return rounds

在这种情况下，每当我们向下导航到一个孩子时，我们将当前深度增加一。在计算节点的分支长度时，我们从深度开始。

顺便说一下。请注意，正式地，内部路径长度被定义为仅内部节点的长度，即不是叶子。上述方法计算包括叶子在内的每个节点。如果你想遵循官方定义，你必须在开头添加一个叶子检查并返回0叶子。

其他一些事情：

方法getLeftChild和getRightChild实际上没有任何效果。您将None指定给返回值，然后检查左/右子项是否为None，如果不是这种情况，则将子项指定给返回值并将其返回。

基本上，你要回归self.leftChild / self.rightChild;没有必要实际查看值并检查None。
在Python中，您通常不使用访问器或增变器方法（getter / setter）;您只需访问底层属性本身。这使得方法getLeftChild，getRightChild，getKey和setKey变得多余。
使用None或!= None检查== None是反模式。如果您想检查例如某个孩子是否None，请执行if child。如果你想检查它是否未设置（即不是None），只需if not child。

树枝的长度之和

1 个答案: