Bereken de diepte van een binaire zoekboom?

Denk na over hoe je zou gaan over dit canoniek met de hand als ik een foto van een BST aan u op een vel papier had gepresenteerd. Als je op een knooppunt, welke informatie heb je nodig om bij te houden? Hoe kan men de hoogte van een bepaald knooppunt te vinden?

Vanaf hier proberen om dit te vertalen naar pseudocode of zelfs direct in Java. Als u problemen ondervindt, voel je vrij om zo te reageren gebruikers kunnen u verder helpen.

Je hoeft alleen maar tot een diepte teller te houden terwijl je de boom doorkruisen (kijk omhoog boom traversals als je moet) en voeg de waarde van de teller elke keer dat je een knooppunt te bereiken. Dan gewoon delen door het aantal knooppunten.

Dit ziet eruit als huiswerk dus ik ben niet met een meer gedetailleerde oplossing.

Is dit huiswerk? Als dat zo is tag de vraag als zodanig.

Je kon een methode die te maken:

• een knooppunt referentie en een diepte argumenten
• increment diepte
• als knooppunt is niet een kind knooppunt oproep recursief voor links en rechts en bijwerken som dienovereenkomstig
• anders sum + diepte terugkeren

Zodra u dit devide door het aantal kinderen in de boom om de gemiddelde diepte te krijgen.

We moeten alle blad nodes te bezoeken en erachter te komen hoe diep ze zijn. Dit suggereert:

Geef je knooppunt-bezoek aan de functie een extra argument. Het moet niet alleen weten waar het heen gaat, maar ook hoe diep het is. Elke keer als het heet, heet het op om dieper te gaan, zodat uw knooppunt bezoeker heeft alleen maar om de diepte nummer het kreeg van de beller te verhogen.

Nu is een van 2 dingen kunnen gebeuren:

• Ofwel het knooppunt u gevonden is een blad knooppunt, dat wil zeggen het heeft geen kinderen; in dit geval, uw bezoeker nodig heeft om de diepte terug te keren naar de beller. Ja, het geeft alleen het nummer het kreeg van de beller, + 1.

• of het is niet een leaf node. In dat geval zal het 1 of 2 kinderen. We moeten die gedetailleerde rapporten van onze kinderen krijgen een back-up naar de beller, dus gewoon de som van de diepten geretourneerd door de kinderen te laten terugkeren.

Door de magie van recursie, het aantal terug naar bezoeker de wortel zal de som van de diepten van alle kinderen.

Om een ​​gemiddelde diepte te krijgen, wil je deze delen door het aantal blad nodes; wat ik zou verlaten om een ​​tweede traversal te berekenen. Het kan worden gedaan in een, maar het zou een beetje ingewikkelder.

Aangezien dit huiswerk, wil ik niet te geven je gewoon een antwoord. In plaats daarvan, hier is een recursieve manier om de lengte van een enkelvoudig gelinkte lijst berekenen. Hopelijk zal dit recursie te tonen op een manier die je kunt begrijpen, en je kunt extrapoleren van daar naar uw BST probleem op te lossen.

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