Wie die Tiefe eines binären Suchbaum berechnen

Für jeden gegebenen Baum, ist die Anzahl des Knoten 1 für die Wurzel plus der Anzahl von Knoten in dem linken Teilbaum plus der Anzahl von Knoten in dem rechten Teilbaum :)

Details, wie eigentlich sicher , dass es zu machen ist eine linke oder rechte Teilbaum werden „dem Leser überlassen“.

Etwas wie das:

int countChildren(Node node)
{
    if ( node == null )
        return 0;
    return 1 + countChildren(node.getLeft()) + countChildren(node.getRight());
}

Und die Summe der Tiefen eines jeden Kindes zu bekommen:

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);
}

Jetzt für eine hoffentlich informative Erklärung für den Fall , ist diese Hausaufgaben. Die Anzahl der Knoten zu zählen ist ganz einfach. Erstens, wenn der Knoten keinen Knoten (ist node == null) gibt es 0. Wenn es einen Knoten ist, zählt er zuerst seine Selbst (die 1) plus die Anzahl der Knoten in dem linken Teilbaum plus die Anzahl der Knoten in sein rechter Unterbaum. Eine weitere Möglichkeit , daran zu denken ist , dass Sie jeden Knoten über BFS besuchen, und geben Sie eine der Zählung für jeden Knoten , den Sie besuchen.

Die Summation von Tiefen ähnlich ist, mit der Ausnahme statt nur einen für jeden Knoten hinzufügen, fügt der Knoten die Tiefe seiner Selbst. Und es kennt die Tiefe seiner selbst, weil seine Eltern davon erzählt. Jeder Knoten weiß, dass die Tiefe der es Kinder gibt es eigene Tiefe ist plus eins, so dass, wenn Sie die Tiefe der linken und rechten Kinder eines Knotens erhalten, können Sie sie sagen, ihre Tiefe ist die aktuelle Tiefe des Knotens plus 1.

Und wieder, wenn der Knoten kein Knoten ist, hat es keine Tiefe. Wenn Sie also die Summe der Tiefe aller Wurzelknoten Kinder wollen, übergeben Sie in dem Wurzelknoten und die Tiefe des Wurzelknoten in etwa so:sumDepthOfAllChildren(root, 0)

Rekursion ist sehr nützlich, es ist nur eine ganz andere Art und Weise über die Dinge zu denken und braucht Übung, um es zu gewöhnen

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;
}

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;
}

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

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

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

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);
}

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);
    }
}

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); 
}

Diese Lösung ist noch einfacher.

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