为什么我的深度函数返回二叉树的高度而不是深度？

Question

我使用Python实现了二进制搜索树。 一切运行正常， nodeHeight()函数返回任何节点的精确高度，但是即使我递归地调用父级的深度， nodeDepth()返回与hegiht相同的答案？ 使用我的类为树实现深度的最佳方法是什么？ 提前致谢！

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

class BST:

    def __init__(self):
        self.root = None

    def insertNode(self, data):
        if self.root != None:
            self._insertNode(self.root, data)
        else:
            self.root = Node(data)


    def _insertNode(self, node, data):
        if data < node.data:
            if node.left == None:
                node.left = Node(data)
                node.left.parent = node
            else:
                self._insertNode(node.left, data)
        elif data > node.data:
            if node.right == None:
                node.right = Node(data)
                node.right.parent = node
            else:
                self._insertNode(node.right, data)
        else:
            self._insertNode(node.right, data)


    def printNodes(self):
        if self.root != None:
            self._printNodes(self.root)

    def _printNodes(self, node):
        if node != None:
            self._printNodes(node.left)
            print(str(node.data))
            self._printNodes(node.right)

    def returnNode(self, data):
        if self.root != None:
            return self._returnNode(self.root, data)

    def _returnNode(self, node, data):
        if node.data == data:
            return node
        elif data < node.data and node.left != None:
            return self._returnNode(node.left, data)
        elif data > node.data and node.right != None:
            return self._returnNode(node.right, data)
        else:
            return 'Node not in tree'

    def isExternal(self, node):
        return node.left == None and node.right == None


    def nodeHeight(self, value):
        node = self.returnNode(value)
        if node != None:
            return self._nodeHeight(node, 0)

    def _nodeHeight(self, node, curHeight):
        if node == None or self.isExternal(node):
            return curHeight
        left_height = self._nodeHeight(node.left, curHeight + 1)
        right_height = self._nodeHeight(node.right, curHeight + 1)

        return max(left_height, right_height)

    def treeHeight(self):
        if self.root != None:
            return self.nodeHeight(self.root.data)
        else:
            return "no tree"

    def searchTree(self, data):
        if self.root != None:
            return self._searchTree(self.root, data)
        else:
            return False

    def _searchTree(self, node, data):
        if data == node.data:
            return True
        elif data < node.data and node.left != None:
            return self._searchTree(node.left, data)
        elif data > node.data and node.right != None:
            return self._searchTree(node.right, data)
        else:
            return "Not in Tree"

    def nodeDepth(self, data):
        node = self.returnNode(data)
        if node != None:
            return self._nodeDepth(node, 0)
        else:
            return "Node is None"

    def _nodeDepth(self, node, curDepth):
        if node == None or node == self.root:
            return 0
        return self.nodeDepth(node.parent, curDepth + 1)



tree = BST()
tree.insertNode(3)
tree.insertNode(7)
tree.insertNode(1)
tree.insertNode(5)

print(tree.nodeHeight(3))
print(tree.nodeHeight(3))

Answer 1

您的代码在这里不调用nodeDepth ，而是两次调用nodeHeight 。

您的nodeDepth函数在我看来确实有缺陷。 我看不到它如何可以返回除0以外的任何值。最简单的解决方法是更改_nodeDepth以将其添加到父级的高度。

def nodeDepth(self, data):
    node = self.returnNode(data)
    if node != None:
        return self._nodeDepth(node)
    else:
        return "Node is None"

def _nodeDepth(self, node):
    if node == None or node == self.root:
        return 0
    return self._nodeDepth(node.parent) + 1

最好的解决方案是编写returnNode函数的版本，该版本在通过树递归时跟踪深度。 这样一来，您可以在找到节点后停止，而无需再次冒充树。

def nodeDepth(self, data):
    return self._nodeDepth(self.root, data)


def _nodeDepth(self, curr, data):
    if curr is None:
        return None
    if curr.data == data:
        return 0
    path = curr.left if data < curr.data else curr.right
    result = self._nodeDepth(path, data)
    if result is None:
        return None
    return result + 1