Calcule la profundidad de un árbol de búsqueda binario?

Piense en cómo podría hacerlo canónicamente a mano si le hubiera presentado una fotografía de una BST en una hoja de papel. Cuando estás en un nodo, ¿de qué información necesitas hacer un seguimiento? ¿Cómo se puede encontrar la altura de un nodo dado?

Desde aquí, intenta traducir esto en pseudocódigo o incluso directamente en Java. Si tiene problemas, no dude en hacer comentarios para que los usuarios puedan ayudarlo.

Solo necesita mantener un contador de profundidad mientras recorre el árbol (busque traversales en el árbol si es necesario) y agregue el valor del contador cada vez que llegue a un nodo. Luego solo divida por la cantidad de nodos.

Esto parece tarea, así que no estoy brindando una solución más detallada.

¿Es esta tarea? Si es así, marque la pregunta como tal.

Puede crear un método que:

• tiene una referencia de nodo y una profundidad como argumentos
• profundidad de incremento
• si el nodo no es un nodo secundario, llame de forma recursiva para la izquierda y la derecha y actualice la suma en consecuencia
• de lo contrario, devuelva suma + profundidad

Una vez que tenga esto divídase por la cantidad de niños en el árbol para obtener la profundidad promedio.

Necesitamos visitar todos los nodos de las hojas y descubrir qué tan profundos son. Esta sugerencia:

Dele a su función de visita a nodos un argumento adicional. Necesita saber no solo hacia dónde va, sino también qué tan profundo es. Cada vez que se invoca, se requiere que vaya más profundo, por lo que el visitante de su nodo solo tiene que incrementar el número de profundidad que recibió de la persona que llama.

Ahora puede suceder una de dos cosas:

• O el nodo que encontraste es un nodo hoja, es decir, no tiene hijos; en este caso, su visitante debe devolver su profundidad a la persona que llama. Sí, solo devuelve el número que recibió de la persona que llama, +1.

• o no es un nodo de hoja. En ese caso, tendrá 1 o 2 niños. Tenemos que hacer que los informes de profundidad de nuestros hijos vuelvan a la persona que llama, así que simplemente devuelva la suma de las profundidades devueltas por los niños.

Por la magia de la recursión, el número devuelto al visitante de la raíz será la suma de las profundidades de todos los niños.

Para obtener una profundidad promedio, querrás dividir esto por la cantidad de nodos hoja; que dejaría para un segundo recorrido para calcular. Se podría hacer en uno, pero sería un poco más complicado.

Ya que esto es tarea, no quiero solo darte una respuesta. En cambio, aquí hay una forma recursiva de calcular la longitud de una lista vinculada individualmente. Con suerte, esto demostrará la recursión de una manera que usted pueda comprender, y puede extrapolar desde allí para resolver su problema de BST.

public final class LL {
    public final int value;
    public LL next;

    public LL(final int value) {
        this.value = value;
    }

    public void add(final int value) {
        if (null == next) {
            next = new LL(value);
        } else {
            next.add(value);
        }
    }

    /**
     * Calculate the length of the linked list with this node as its head (includes this node in the count).
     *
     * @return the length.
     */
    public int length() {
        if (null == next) {
            return 1;
        }
        return 1 + next.length();
    }

    public static void main(final String... args) {
        final LL head = new LL(1);
        head.add(2);
        head.add(3);
        System.out.println(head.length());
        System.out.println(head.next.length());
    }
}