Come calcolare la profondità di un albero binario di ricerca

Per ogni dato albero, il numero di nodi è 1 per la radice più il numero di nodi nel sottoalbero sinistro più il numero di nodi nel sottoalbero destro :)

Dettagli, come assicurandosi che non ci realmente è una sottostruttura a sinistra oa destra, sono "lasciati al lettore".

Qualcosa come questo:

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

E per ottenere la somma delle profondità di ogni bambino:

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

Ora, per una spiegazione si spera informativa nel caso in cui questo è compiti. Contare il numero di nodi è abbastanza semplice. Prima di tutto, se il nodo non è un nodo ( node == null) restituisce 0. Se si tratta di un nodo, in primo luogo conta la sua auto (la 1), più il numero di nodi nel suo sinistro sotto-albero più il numero di nodi in il suo diritto sub-albero. Un altro modo di pensare è che si visita ogni nodo tramite BFS, e aggiungere uno per il conteggio per ogni nodo che si visita.

La somma delle profondità è simile, tranne che invece di aggiungere solo uno per ciascun nodo, il nodo aggiunge la profondità della sua auto. E si sa che la profondità della sua auto, perché suo padre ha detto che. Ogni nodo sa che la profondità del suo bambini sono il proprio profondità più uno, in modo che quando si ottiene la profondità di sinistra e di destra i figli di un nodo, è dire loro la loro profondità è la profondità del nodo corrente più 1.

E ancora, se il nodo non è un nodo, non ha profondità. Quindi, se si desidera che la somma della profondità di tutti i bambini del nodo principale, si passa al nodo principale e la profondità del nodo principale in questo modo:sumDepthOfAllChildren(root, 0)

La ricorsione è molto utile, è solo un modo molto diverso di pensare le cose e vuole pratica per abituarsi ad esso

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

Questa soluzione è ancora più semplice.

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