如何计算二叉搜索树的深度

Posted 2023-02-25

【中文标题】如何计算二叉搜索树的深度

【英文标题】：How to calculate the depth of a binary search tree

【发布时间】：2010-12-24 23:28:28

【问题描述】：

我想计算二叉搜索树每个节点的深度总和。

元素的各个深度尚未存储。

【问题讨论】：

在人们提供答案后更改问题将使原始答案看起来与最新问题无关。你也不能接受两个答案。最好问一个新问题，即在新页面上。您可能还想接受原始问题的答案。

【参考方案1】：

类似这样的：

int countChildren(Node node)

    if ( node == null )
        return 0;
    return 1 + countChildren(node.getLeft()) + countChildren(node.getRight());

并得到每个孩子的深度总和：

int sumDepthOfAllChildren(Node node, int depth)

    if ( node == null )
        return 0;  // starting to see a pattern?
    return depth + sumDepthOfAllChildren(node.getLeft(), depth + 1) + 
                   sumDepthOfAllChildren(node.getRight(), depth + 1);

如果这是家庭作业，现在有希望提供信息丰富的解释。计算节点的数量非常简单。首先，如果节点不是节点（node == null），则返回 0。如果是节点，则首先计算自身（1），加上其左子树中的节点数加上其右子树中的节点数。另一种思考方式是您通过 BFS 访问每个节点，并为您访问的每个节点添加一个计数。

深度的总和是相似的，除了不是为每个节点只添加一个，而是节点添加其自身的深度。它知道自己的深度，因为它的父母告诉了它。每个节点都知道它的孩子的深度是它自己的深度加一，所以当你得到一个节点的左右孩子的深度时，你告诉他们他们的深度是当前节点的深度加1。

同样，如果节点不是节点，它就没有深度。所以如果你想要所有根节点的子节点的深度之和，你可以像这样传递根节点和根节点的深度：sumDepthOfAllChildren(root, 0)

递归非常有用，它只是一种非常不同的思考方式，需要练习才能习惯它

【讨论】：

我想指出，Kyle 指的是我的第一个函数，而不是后来添加的解释，质量可疑。

【参考方案2】：

int maxDepth(Node node) 
    if (node == null) 
        return (-1); // an empty tree  has height −1
     else 
        // compute the depth of each subtree
        int leftDepth = maxDepth(node.left);
        int rightDepth = maxDepth(node.right);
        // use the larger one
        if (leftDepth > rightDepth )
            return (leftDepth + 1);
        else
            return (rightDepth + 1);
    

【讨论】：

为什么要 +1 作为回报？

因为你已经遍历了一层并进入了下一层。如果没有 +1，您将始终得到零作为最大深度。

我们不需要在开始计数之前将leftDepth和rightDepth初始化为零吗？

【参考方案3】：

这个解决方案更简单。

public int getHeight(Node root)

    if(root!=null)
        return 1+ Math.max(getHeight(root.leftchild),getHeight(root.rightchild));
    else
        return 0;

【参考方案4】：

对于任何给定的树，根节点的数量是 1 加上左子树中的节点数加上右子树中的节点数:)

细节，比如确保确实存在左子树或右子树，是“留给读者的”。

【讨论】：

卡尔是对的。最简单的方法是： public int countNodes(Node root) if(root == null) return 0;返回 1 + countNodes(root.getLeft()) + countNodes(root.getRight());

原始海报：这并不能帮助我真正做到这一点：P。阅读问题，在遍历 BST 时，我很难在递归方法中保留节点数的总和。

你不需要保留任何东西，就像 Gennadiy 上面演示的那样。

您不必保留金额。您需要做的就是找到最多 3 个数字的总和并将其返回给您的呼叫者。

【参考方案5】：

private static int getNumberOfNodes(Node node) 
    if (node == null) 
        return 0;
    

    return 1 + getNumberOfNodes(node.left) + getNumberOfNodes(node.right);

【参考方案6】：

public int countNodes(Node root)
  
   // Setup
   // assign to temps to avoid double call accessors. 
   Node left = root.getLeft();
   Node right = root.getRight();
   int count = 1; // count THIS node.

   // count subtrees
   if (left != null) count += countNodes(left);
   if (right != null) count += countNodes(right);

   return count;

【参考方案7】：

public class Node 
   private Node left; 
   private Node right;
   public int size()  return 1+ (left==null?0:left.size())+ (right==null?0:right.size());

【参考方案8】：

int depth(treenode *p)

   if(p==NULL)return(0);
   if(p->left)h1=depth(p->left);
   if(p=>right)h2=depth(p->right);
   return(max(h1,h2)+1);

【参考方案9】：

public int numberOfNodes()

   // This node.
   int result = 1;

   // Plus all the nodes from the left node.
   Node left = getLeft();
   if (left != null)
       result += left.numberOfNodes();

   // Plus all the nodes from the right node.
   Node right = getRight();
   if (right != null)
       result += right.numberOfNodes();

   return result;

【参考方案10】：

public int getDepthHelper( TreeNode< T > node )  
    int treeHeightLeft; 
    int treeHeightRight; 
    //get height of left subtree 
    if( node.leftNode == null ) 
        treeHeightLeft = 1; 
    else  
        treeHeightLeft = getDepthHelper( node.leftNode) + 1; 
     

    //get height of right subtree 
    if( node.rightNode == null ) 
        treeHeightRight = 1; 
    else  
        treeHeightRight = getDepthHelper( node.rightNode) + 1; 
     
    return Math.max(treeHeightLeft, treeHeightRight);