Cómo calcular la profundidad de un árbol de búsqueda binario

Para cualquier árbol dado, el número de nodos es 1 para la raíz más la cantidad de nodos en el subárbol izquierdo más el número de nodos en el subárbol derecho :)

Los detalles, como asegurarse de que realmente hay un subárbol izquierdo o derecho, son "dejados al lector".

Algo como esto:

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

Y para obtener la suma de las profundidades de cada niño:

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

Ahora para una explicación con suerte informativa en caso de que esto sea tarea. Contar la cantidad de nodos es bastante simple. En primer lugar, si el nodo no es un nodo ( node == null) devuelve 0. Si es un nodo, primero cuenta su propio (el 1), más el número de nodos en su subárbol izquierdo más el número de nodos en su subárbol correcto. Otra forma de pensarlo es que visita cada nodo a través de BFS y agrega uno al recuento de cada nodo que visita.

La suma de profundidades es similar, excepto que en lugar de agregar solo una para cada nodo, el nodo agrega la profundidad de su yo. Y conoce la profundidad de su yo porque su padre lo contó. Cada nodo sabe que la profundidad de sus hijos es su propia profundidad más uno, de modo que cuando obtiene la profundidad de los hijos izquierdo y derecho de un nodo, les dice que su profundidad es la profundidad del nodo actual más 1.

Y nuevamente, si el nodo no es un nodo, no tiene profundidad. Por lo tanto, si desea la suma de la profundidad de todos los elementos secundarios del nodo raíz, pase el nodo raíz y la profundidad del nodo raíz de la siguiente manera:sumDepthOfAllChildren(root, 0)

La recursividad es bastante útil, es solo una manera muy diferente de pensar sobre las cosas y requiere práctica para acostumbrarse a ella

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

Esta solución es aún más sencillo.

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