Calcolare la profondità di un albero binario di ricerca?

Pensate a come si dovrebbe andare su questo canonicamente a mano se avevo presentato una foto di un BST a voi su un foglio di carta. Quando sei in un nodo, quali informazioni hai bisogno di tenere traccia di? Come si fa a trovare l'altezza di un dato nodo?

Da qui, cercare di tradurre questo in pseudocodice o anche direttamente in Java. Se hai problemi, non esitate a lasciare un commento, così gli utenti possono aiutarti.

Hai solo bisogno di mantenere un contatore di profondità mentre attraversate l'albero (guardare in alto attraversamenti albero se è necessario) e aggiungere il valore del contatore ogni volta che si raggiunge un nodo. Poi basta dividere per il numero di nodi.

Questo appare come compiti a casa quindi non sto fornendo una soluzione più dettagliata.

È questo compito? Se è così tag la questione in quanto tale.

È possibile creare un metodo che:

• ha un riferimento nodo e una profondità come argomenti
• profondità di incremento
• se il nodo non è una chiamata nodo figlio in modo ricorsivo per somma di sinistra e destra e di conseguenza l'aggiornamento
• altrimenti restituisce sum + profondità

Una volta che avete questo devide per il numero di bambini nella struttura per ottenere la profondità media.

Abbiamo bisogno di visitare tutti i nodi foglia e capire quanto in profondità sono. Ciò suggerisce:

Lascia la tua funzione del nodo-visitare un argomento extra. Ha bisogno di sapere non solo dove sta andando, ma anche quanto è profonda. Ogni volta che si chiama, è chiamato ad andare più in profondità, in modo che il visitatore nodo deve solo incrementare il numero di profondità ha ottenuto dal chiamante.

Ora, una delle 2 cose possono accadere:

• Sia il nodo che avete trovato è un nodo foglia, cioè non ha figli; In questo caso, il visitatore ha bisogno di tornare la sua profondità al chiamante. Sì, è proprio restituisce il numero ha ottenuto dal chiamante, + 1.

• o non è un nodo foglia. In questo caso, avrà 1 o 2 bambini. Abbiamo bisogno di ottenere tali relazioni profondità dei nostri bambini torna fino al chiamante, quindi basta restituire la somma delle profondità restituiti dai bambini.

Con la magia della ricorsione, il numero restituito al visitatore di root sarà la somma delle profondità di tutti i bambini.

Per ottenere una profondità media, ti consigliamo di dividere questo per il numero di nodi foglia; che avrei lasciato ad un secondo attraversamento da calcolare. Si potrebbe essere fatto in uno, ma sarebbe un po 'più complicato.

Poiché si tratta di compiti a casa, io non voglio solo dare una risposta. Invece, ecco un modo ricorsivo per calcolare la lunghezza di una lista concatenata. Speriamo che questo dimostrerà ricorsione in un modo si può capire, e si può estrapolare da lì per risolvere il problema 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());
    }
}