Comprensión de conteo de búsqueda binaria Árbol

Sean2148:

Estoy teniendo problemas para entender cómo funciona este método de búsqueda binaria árbol está contando nodos, he mirado muchos ejemplos en línea, sin embargo no puedo encontrar uno que le explicará exactamente lo que está sucediendo.

Aquí hay un ejemplo:

public int nodes() {
    int leftNodes = 0;

    if (left != null) {
        leftNodes = left.nodes();
    }
    int rightNodes = 0;

    if (right != null) {
        rightNodes = right.nodes();
    }
    return leftNodes + rightNodes + 1;
}

Así es como yo soy la comprensión del proceso de este método, y tal vez alguien pueda ayudar a entender a dónde voy mal.

1. El método se llama desde fuera de sí mismo a partir de un objeto de BTS; "tree.nodes (), etc".
2. int leftNodes se declara y establece en 0.
3. Si hay un nodo izquierdo (suponga que hay), se le asignará entonces el valor de leftNodes para el valor de retorno de la llamada a los nodos ();
4. La llamada recursiva pasará por el método de nodos de nuevo, la asignación de leftNodes de nuevo a cero.

Así que lo que no entiendo es donde se incrementa la variable leftNodes? Parece que acaba de manera recursiva a través del método de nuevo, pero el valor no cambia, y de la forma en que veo leftNodes y rightNodes siempre será 0.

He encontrado otro ejemplo de conteo BTS, éste usando C ++

int CountNodes(node*root)
{
if(root==NULL)
    return 0;
if(root->left!=NULL)
{
    n=n+1;
    n=CountNodes(root->left);
}
if(root->right!=NULL)
{
    n=n+1;
    n=CountNodes(root->right);
}
return n;
}

Me parece que este método mucho más fácil de seguir, como n claramente se incrementa cada vez que un nodo se encuentra.

Mi pregunta es ¿cómo es el valor leftNodes / rightNodes se incrementa en la llamada recursiva?

Eran :

Usted debe pensar en el final de la recursividad.

Suponga que tiene un único nodo sin hijos.

Tanto lefty rightsería null, por lo que no hará llamadas recursivas.

Volverá

leftNodes + rightNodes + 1; // 0 + 0 + 1 == 1

Ahora, supongamos que tiene un árbol simple que consiste en una raíz, un hijo izquierdo y derecho de un niño.

Cuando se llama nodes()a la raíz de ese árbol, tanto lefty rightno es nula, por lo tanto vamos a llamar left.nodes()y right.nodes(). Dado que tanto el niños izquierdo y derecho son nodos hoja (es decir, no tienen hijos), las llamadas recursivas tanto para volverán 1, como se explicó anteriormente.

Por lo tanto, cuando se devuelven las llamadas recursivas, vamos a regresar

leftNodes + rightNodes + 1; // 1 + 1 + 1 == 3

que es el número de nodos en nuestro árbol.