Kortste tak in een binaire boom?

Question

Kortste tak in een binaire boom?

stemmen

1

Een binaire boom kan worden gecodeerd met twee functies len r zodanig dat voor een node n, l(n)geven de linker kind n, r(n) geeft de rechter kind n.

Een tak van een boom is een pad vanaf de wortel naar een blad, de lengte van een aftakking naar een bepaald blad het aantal bogen op het pad van de wortel naar dat blad.

Laat MinBranch(l,r,x)een eenvoudig recursief algoritme voor het nemen van een binaire boom gecodeerd door de l en r functies samen met het hoofdknooppunt x de binaire boom en de lengte van de kortste tak van de binaire boom terug.

Geef de pseudocode voor dit algoritme.

OK, dus in principe is dit wat ik hebben bedacht tot nu toe:

MinBranch(l, r, x)
{
    if x is None return 0

    left_one = MinBranch(l, r, l(x))

    right_one = MinBranch(l, r, r(x))

    return {min (left_one),(right_one)}
}

Uiteraard is dit niet groot of perfect. Ik zou dankbaar zijn als mensen me kan helpen dit perfect en werken - het even welke hulp zal worden gewaardeerd.

algorithm binary-tree pseudocode

De vraag is gesteld op 28/08/2009 om 05:07
bron van user helen

In andere talen...

5 antwoorden

Richard Berg · Answer 1 · 2009-08-28 05:15

Ik betwijfel of iemand zal huiswerk voor u oplossen straight-up. Een aanwijzing: de terugkeer waarde moet zeker hoger worden als de boom groter wordt, toch? Maar ik heb geen numerieke literals in uw functie zien, behalve 0, en geen toevoeging operators ook niet. Hoe gaat u steeds grotere aantallen terug te keren?

Een andere hoek over dezelfde kwestie: wanneer u een recursieve functie te schrijven, het helpt om op te noemen "wat zijn alle voorwaarden waar ik moet stoppen met me roepen wat ik terug in alle omstandigheden?"

Stobor · Answer 2 · 2009-08-28 05:16

stemmen

2

Je bent op de juiste aanpak, maar je bent niet helemaal er; recursieve algoritme zal altijd terugkeren 0. (de logica is bijna gelijk, hoewel ...)

merken dat de lengte van de sub-takken één lager is dan de lengte van de aftakking; zo left_oneen right_onezou moeten zijn 1 + MinBranch....

Steping door middel van het algoritme met een aantal bomen in de steekproef zullen helpen ontdekken off-by-one fouten zoals deze ...

antwoordde op 28/08/2009 om 05:16
bron van user Stobor

MadCoder · Answer 3 · 2009-08-28 05:19

stemmen

0

Wat je hebt gemaakt, kan worden gezien als een diepte-eerst zoeken. Echter, gezien wat je na (kortste tak), is dit misschien niet de meest efficiënte aanpak. Denk na over hoe je algoritme zou presteren op een boom die zeer zwaar aan de linkerkant (van de root node) was, maar had slechts één knooppunt aan de rechterkant.

Hint: overweeg een breedte-first search aanpak.

antwoordde op 28/08/2009 om 05:19
bron van user MadCoder

Charles Ma · Answer 4 · 2009-08-28 05:19

stemmen

0

Wat je daar ziet eruit als een diepte eerste zoekalgoritme die zal hebben om de hele boom te zoeken voordat je de proppen te komen met een oplossing. wat je nodig hebt is de breedte eerste zoekopdracht algoritme dat zodra hij de oplossing vindt kan terugkeren zonder het doen van een uitgebreider zoeken

antwoordde op 28/08/2009 om 05:19
bron van user Charles Ma

derobert · Answer 5 · 2009-08-28 05:20

Het lijkt erop dat je het bijna, maar overwegen dit voorbeeld:

      4

   3     5

Wanneer u op te sporen door middel van MinBranch, zult u zien dat in uw MinBranch(l,r,4)gesprek:

left_one = MinBranch(l, r, l(x))
         = MinBranch(l, r, l(4))
         = MinBranch(l, r, 3)
         = 0

Logisch immers 3 een bladknooppunt, zodat natuurlijk de afstand tot de dichtstbijzijnde eindknooppunt 0. Hetzelfde gebeurt right_one.

Maar je dan liquideren hier:

return {min (left_one),(right_one)}
     = {min (0), (0) }
     = 0

maar dat is duidelijk verkeerd, omdat dit knooppunt (4) is niet een blad node. Uw code vergeten om het huidige knooppunt (oeps!) Tellen. Ik weet zeker dat het je lukt om dat te bevestigen.

Nu, eigenlijk, ze manier je doet dit niet de snelste, maar ik ben niet zeker of dat relevant is voor deze oefening. Beschouw deze boom:

Uw algoritme zal recursief tellen de linker tak, hoewel het zou kunnen, hypothetisch, borgtocht uit als je eerst de juiste tak geteld en merkte op dat 3 heeft een links, dus het is duidelijk langer dan 5 (dat is een blad). Maar natuurlijk, het tellen van de juiste tak eerste werkt niet altijd!

In plaats daarvan, met meer ingewikkelde code, en waarschijnlijk een afweging van meer geheugengebruik, kunt u knooppunten controleren van links naar rechts, van boven naar beneden (net als Engels lezen volgorde) en stoppen bij het eerste blad u te vinden.