Javascript 解释递归如何在确定二叉树深度的算法中工作?

Javascript 解释递归如何在确定二叉树深度的算法中工作?,javascript,algorithm,recursion,binary-tree,depth,Javascript,Algorithm,Recursion,Binary Tree,Depth,我不熟悉JavaScript中的数据结构,正在尝试学习二进制搜索树。我一直在关注一篇博文,并且能够找到在BST中查找最大深度问题的有效解决方案,但我不清楚递归是如何工作的,以及每次在每个深度级别上如何添加+1。思考这个问题的好方法是什么?基本上是不是每次节点值不为null时,都会将1添加到最终将返回到调用堆栈的内容中(即,在回溯到根的每个级别) maxDepth(node)的代码如下: 如果节点不是空: 在节点的左子节点上运行相同的算法maxDepth。让这个答案为x 在节点的右子节点上运行相同

我不熟悉JavaScript中的数据结构,正在尝试学习二进制搜索树。我一直在关注一篇博文,并且能够找到在BST中查找最大深度问题的有效解决方案,但我不清楚递归是如何工作的,以及每次在每个深度级别上如何添加+1。思考这个问题的好方法是什么?基本上是不是每次节点值不为null时,都会将1添加到最终将返回到调用堆栈的内容中(即,在回溯到根的每个级别)


maxDepth(node)
的代码如下:

  • 如果
    节点
    不是

  • 节点的左子节点上运行相同的算法
    maxDepth
    。让这个答案为
    x
  • 节点的右子节点上运行相同的算法
    maxDepth
    。让这个答案为
    y
  • 计算
    Math.max(x,y)+1
    ,并返回此值作为此函数调用的答案
  • 否则,
    节点
    null
    ,然后返回
    0


  • 这意味着当我们试图在非空节点上计算
    maxDepth(node)
    时,我们首先在
    node
    的两个子节点上计算
    maxDepth()。然后取这些值的最大值,加1,然后返回结果

    示例:

          a
         / \
        b   f
       / \   \
      c   e   g
     /           
    d 
    
    调用堆栈:

    a => max(b,f)
    b => max(c,e)
    c => max(d,null)
    d => max(null,null)
    d <= (0,0)+1 = 1
    c <= (1,0)+1 = 2
    e => max(null,null)
    e <= (0,0)+1 = 1
    b <= (2,1)+1 = 3
    f => (null,g)
    g => (null,null)
    g <= (0,0)+1 = 1
    f <= (0,1)+1 = 2
    a <= (3,2)+1 = 4
    
    a=>max(b,f)
    b=>最大值(c,e)
    c=>最大值(d,空)
    d=>最大值(空,空)
    
    为了便于更好地解释,让我用一种更简单的方式重写代码

    function maxDepth(node) {
      if (node == null)
          return 0;
      else {
          l = maxDepth(node.left)
          r = maxDepth(node.right)
          return Math.max(left, right) + 1;
      }
    }
    
    现在,让我们用下面的树来解释上述递归:

          A
         / \
        B   C
       /    
      D      
                
    
    函数
    maxDepth(node)
    用根(
    A
    )调用,因此,我们将从node
    A
    开始以图形方式解释递归堆栈:

    A
    | l = ?
    |-------> B
    |         | l = ?
    |         |-------> D
    |         |         | l = ?
    |         |         |-------> null (return 0)
    
    A
    | l = ?
    |-------> B
    |         | l = ?
    |         |-------> D
    |         |         | l = 0 <---------|
    |         |         |-------> null (return 0)
    
    A
    | l = ?
    |-------> B
    |         | l = ?
    |         |-------> D
    |         |         | l = 0 
    |         |         |
    |         |         | r = ?
    |         |         |-------> null (return 0)
    
    A
    | l = ?
    |-------> B
    |         | l = ?
    |         |-------> D
    |         |         | l = 0 
    |         |         |
    |         |         | r = 0 <---------|
    |         |         |-------> null (return 0)
    
    A
    | l = ?
    |-------> B
    |         | l = ? <--------------------------|
    |         |-------> D                        |
    |         |         | l = 0                  |
    |         |         |          max(0,0)+1 => 1
    |         |         | r = 0 
    
    
    A
    | l = ?
    |-------> B
    |         | l = 1 <--------------------------|
    |         |-------> D                        |
    |         |         | l = 0                  |
    |         |         |          max(0,0)+1 => 1
    |         |         | r = 0 
    
    
    A
    | l = ?
    |-------> B
    |         | l = 1 
    |         |
    |         | r = ? 
    |         | -------> null (return 0)
    
    A
    | l = ?
    |-------> B
    |         | l = 1 
    |         |
    |         | r = 0 <---------| 
    |         | -------> null (return 0)
    
    
    A
    | l = ? <--------------------------|
    |-------> B                        |
    |         | l = 1                  | 
    |         |          max(1,0)+1 => 2
    |         | r = 0
    
    A
    | l = 2 <--------------------------|
    |-------> B                        |
    |         | l = 1                  | 
    |         |          max(1,0)+1 => 2
    |         | r = 0
    
    A
    | l = 2 
    |
    | r = ?        
    | -------> C 
    |          | l = ? <---------| 
    |          |-------> null (return 0)
    
    A
    | l = 2 
    |
    | r = ?        
    | -------> C 
    |          | l = 0 
    |          |
    |          | r = ? <---------| 
    |          |-------> null (return 0)
    
    A
    | l = 2 
    |
    | r = ? <---------------------------|        
    | -------> C                        | 
    |          | l = 0                  | 
    |          |          max(0,0)+1 => 1
    |          | r = 0 
    
    A
    | l = 2 
    |
    | r = 1 <---------------------------|        
    | -------> C                        | 
    |          | l = 0                  | 
    |          |          max(0,0)+1 => 1
    |          | r = 0 
    
    
    A <----------------------|  
    | l = 2                  |  
    |          max(2,1)+1 => 3
    | r = 1 
    

    您问题的上半部分,以及
    maxDepth()
    函数,足够我们回答。您可以删除第二块代码。
    A
    | l = ?
    |-------> B
    |         | l = ?
    |         |-------> D
    |         |         | l = ?
    |         |         |-------> null (return 0)
    
    A
    | l = ?
    |-------> B
    |         | l = ?
    |         |-------> D
    |         |         | l = 0 <---------|
    |         |         |-------> null (return 0)
    
    A
    | l = ?
    |-------> B
    |         | l = ?
    |         |-------> D
    |         |         | l = 0 
    |         |         |
    |         |         | r = ?
    |         |         |-------> null (return 0)
    
    A
    | l = ?
    |-------> B
    |         | l = ?
    |         |-------> D
    |         |         | l = 0 
    |         |         |
    |         |         | r = 0 <---------|
    |         |         |-------> null (return 0)
    
    A
    | l = ?
    |-------> B
    |         | l = ? <--------------------------|
    |         |-------> D                        |
    |         |         | l = 0                  |
    |         |         |          max(0,0)+1 => 1
    |         |         | r = 0 
    
    
    A
    | l = ?
    |-------> B
    |         | l = 1 <--------------------------|
    |         |-------> D                        |
    |         |         | l = 0                  |
    |         |         |          max(0,0)+1 => 1
    |         |         | r = 0 
    
    
    A
    | l = ?
    |-------> B
    |         | l = 1 
    |         |
    |         | r = ? 
    |         | -------> null (return 0)
    
    A
    | l = ?
    |-------> B
    |         | l = 1 
    |         |
    |         | r = 0 <---------| 
    |         | -------> null (return 0)
    
    
    A
    | l = ? <--------------------------|
    |-------> B                        |
    |         | l = 1                  | 
    |         |          max(1,0)+1 => 2
    |         | r = 0
    
    A
    | l = 2 <--------------------------|
    |-------> B                        |
    |         | l = 1                  | 
    |         |          max(1,0)+1 => 2
    |         | r = 0
    
    A
    | l = 2 
    |
    | r = ?        
    | -------> C 
    |          | l = ? <---------| 
    |          |-------> null (return 0)
    
    A
    | l = 2 
    |
    | r = ?        
    | -------> C 
    |          | l = 0 
    |          |
    |          | r = ? <---------| 
    |          |-------> null (return 0)
    
    A
    | l = 2 
    |
    | r = ? <---------------------------|        
    | -------> C                        | 
    |          | l = 0                  | 
    |          |          max(0,0)+1 => 1
    |          | r = 0 
    
    A
    | l = 2 
    |
    | r = 1 <---------------------------|        
    | -------> C                        | 
    |          | l = 0                  | 
    |          |          max(0,0)+1 => 1
    |          | r = 0 
    
    
    A <----------------------|  
    | l = 2                  |  
    |          max(2,1)+1 => 3
    | r = 1 
    
    3
    ^
    |
    A (3)<-------------------|  
    | l = 2                  |  
    |          max(2,1)+1 => 3
    | r = 1