Comment calculer la profondeur d'un arbre de recherche binaire

Pour tout arbre donné, le nombre de noeuds est 1 pour la racine, plus le nombre de nœuds dans le sous-arbre gauche plus le nombre de noeuds dans le sous-arbre droit :)

Détails, comme en vous assurant qu'il fait est un sous - arbre gauche ou à droite, sont « laissés au lecteur ».

Quelque chose comme ça:

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

Et pour obtenir la somme des profondeurs de chaque enfant:

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

Maintenant , pour une explication en cas d' information , espérons - ce est des devoirs. Compter le nombre de nœuds est assez simple. Tout d' abord, si le nœud est pas un noeud ( node == null) renvoie 0. Si elle est un nœud, il compte d' abord son auto (le 1), ainsi que le nombre de nœuds dans son sous-arbre gauche plus le nombre de noeuds son sous-arbre droit. Une autre façon de penser est que vous visitez chaque noeud via BFS, et d' ajouter un au comptage pour chaque nœud que vous visitez.

La somme des profondeurs est similaire, sauf au lieu d'ajouter seulement un pour chaque nœud, le nœud ajoute la profondeur de son auto. Et il connaît la profondeur de son auto parce que son parent a dit qu'il. Chaque nœud sait que la profondeur de c'est les enfants sont sa propre profondeur, plus un, alors quand vous obtenez la profondeur des enfants gauche et à droite d'un nœud, vous leur dire leur profondeur est la profondeur du nœud courant plus 1.

Et encore, si le nœud est pas un nœud, il n'a pas de profondeur. Donc, si vous voulez que la somme de la profondeur de tous les enfants du nœud racine, vous passez dans le nœud racine et la profondeur du nœud racine comme ceci:sumDepthOfAllChildren(root, 0)

La récursivité est très utile, il est juste une façon très différente de penser à des choses et prend la pratique pour s'y habituer

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

Cette solution est encore plus simple.

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