Calculer la profondeur d'un arbre de recherche binaire?

Pensez à la façon dont vous allez sur ce canoniquement la main si j'avais présenté une photo d'un BST pour vous sur une feuille de papier. Lorsque vous êtes à un nœud, quelles informations avez-vous besoin de garder une trace de? Comment peut-on trouver la hauteur d'un noeud donné?

A partir de là, essayer de traduire en pseudocode ou même directement dans Java. Si vous rencontrez des problèmes, ne hésitez pas à commenter afin que les utilisateurs peuvent vous aider.

Vous avez juste besoin de garder un compteur de profondeur que vous traversez l'arbre (regarder traversals d'arbres si vous devez) et ajoutez la valeur du compteur chaque fois que vous atteignez un nœud. Ensuite, il suffit de diviser par le nombre de nœuds.

Cela ressemble à des devoirs, donc je ne suis pas fournir une solution plus détaillée.

Est-ce devoir? Si Baliser la question en tant que telle.

Vous pouvez créer une méthode qui:

• a une référence de noeud et une profondeur en tant qu'arguments
• profondeur incrément
• si le nœud est pas un appel de nœud enfant récursive pour somme gauche et à droite et mise à jour en conséquence
• sinon revenir somme + profondeur

Une fois que vous avez ce Devide par le nombre d'enfants dans l'arbre pour obtenir la profondeur moyenne.

Nous avons besoin de visiter tous les nœuds de feuilles et de comprendre la profondeur qu'ils sont. Ceci suggère:

Donnez votre fonction nœud visite un argument supplémentaire. Il a besoin de savoir non seulement où il va, mais aussi la profondeur est. Chaque fois qu'il est appelé, il est appelé à aller plus loin, de sorte que votre noeud visiteur a juste pour augmenter le nombre de profondeur, il a obtenu de l'appelant.

Maintenant, l'une des 2 choses peuvent se produire:

• Soit le nœud que vous avez trouvé est un nœud feuille, dire qu'il ne pas d'enfants; dans ce cas, votre visiteur a besoin de retourner sa profondeur à l'appelant. Oui, il retourne juste le nombre qu'il a obtenu de l'appelant, + 1.

• ou ce n'est pas un nœud feuille. Dans ce cas, il aura soit 1 ou 2 enfants. Nous avons besoin de revenir si juste la somme des profondeurs retournées par les enfants ces rapports de profondeur de nos enfants de retour à l'appelant,.

Par la magie de récursion, le nombre est retourné au visiteur de la racine sera la somme des profondeurs de tous les enfants.

Pour obtenir une profondeur moyenne, vous aurez envie de diviser par le nombre de nœuds feuilles; que je laisse une seconde traversal pour calculer. Cela pourrait se faire en une seule, mais ce serait un peu plus compliqué.

Puisque c'est des devoirs, je ne veux pas vous donner une réponse. Au lieu de cela, voici une façon récursive pour calculer la longueur d'une liste chaînée. Espérons que cela démontrera récursion une manière que vous pouvez comprendre, et vous pouvez extrapoler à partir de là pour résoudre votre problème 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());
    }
}