Question

对于二叉搜索树，我有两个单独的getHeight（）方法实现（不一定是平衡的BST），一个是迭代的，一个是递归的。这是迭代的：

def height(root): #iterative approach, uses a stack for a depth first search
    max_height = 0
    myStack = [root]
    currentNode = None
    root.level = True

    while len(myStack) != 0:
        currentNode = myStack[-1]
        if currentNode.left is not None and currentNode.left.level is not True:
            myStack.append(currentNode.left)
            currentNode.left.level = True
            continue
        if currentNode.right is not None and currentNode.right.level is not True:
            myStack.append(currentNode.right)
            currentNode.right.level = True
            continue
        elif (currentNode.left is None or currentNode.left.level is True) and (currentNode.right is None or currentNode.right.level is True):
            height = len(myStack) - 1
            if height > max_height:
              max_height = height
            myStack.pop()
return max_height

这是递归方法：

def recurseHeight(root):
    add = 0
    l, r = 0, 0
    if root.left is not None:
        l = 1 + recurseHeight(root.left)
    if root.right is not None:
        r = 1 + recurseHeight(root.right)

    return l if l > r else r

因此，从空间复杂性的角度来看，递归算法更好。但是，根据我的理解，迭代算法的运行时间是O（n）（因为它必须搜索所有n个节点，并且直到那个点才会停止），但我想知道递归算法的运行时是什么是。我知道我必须使用主定理，而我的一部分认为它也是O（n），因为无论如何我都必须访问所有节点，但我不确定。任何人都可以帮助找到递归算法的运行时间吗？

（旁注，我这样做是为了接受采访 - 如果有人有好的问题/学习资源，不要犹豫地大声说出自己的话:)）

Answer 1

正如您所说的那样O（n）因为您总是访问树中的每个节点并且只访问每个节点一次，这意味着您需要O（n）的递归版本工作

用于二叉搜索树的两个单独的getHeight算法的运行时

1 个答案: