1 / 37

Datastructuren Zoekbomen II

Datastructuren Zoekbomen II. Invoegen en weglaten. Dit onderwerp. Binaire Zoekbomen: vorige keer Wat is een binaire zoekboom (eigenschap) Zoeken Minimum Maximum Opvolger / Voorganger Binaire Zoekbomen: nu Een extra query (vb) Invoegen Weglaten Binaire Zoekbomen: hierna

ava-gillespie
Download Presentation

Datastructuren Zoekbomen II

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. DatastructurenZoekbomen II Invoegen en weglaten

  2. Dit onderwerp • Binaire Zoekbomen: vorige keer • Wat is een binaire zoekboom (eigenschap) • Zoeken • Minimum • Maximum • Opvolger / Voorganger • Binaire Zoekbomen: nu • Een extra query (vb) • Invoegen • Weglaten • Binaire Zoekbomen: hierna • Optuigen: snelle “order queries” • Balanceren: zorg dat de diepte O(log n) blijft

  3. Wortel bevat een key (met pointer naar bijbehorend object met extra gegevens …) Linker deelboom bevat alleen kleinere (£)keys Rechter deelboom bevat alleen grotere (³) keys Soms sta je toe dat een key vaker voorkomt, soms niet Binaire zoekboom 47 65 42 55 67 23 45 49 60 99 31 12

  4. Je kan ook de NIL’s tekenen Binaire zoekboom 47 65 42 55 67 23 49 60 99 31 12

  5. Iterative-Tree-Search(x,k) while (x != NIL andk != key(x)) do if ( k < key(x)) then x = left(x) elsex = right(x) return x; Zoeken in een binaire boom 47 65 42 55 67 23 49 60 99 31 12 Kost O(h) tijd als boom hoogte h heeft

  6. Tree-Minimum(x) {Zoek het minimum in de boom met wortel x} while (left(x) != NIL) do x = left(x); return x; Zoeken van Minimum 47 65 42 55 67 23 49 60 99 31 12 Het minimum is altijd de “meest linkse” knoop Tijd: O(h) – h hoogte van de boom

  7. Tree-Maximum(x) {Zoek het minimum in de boom met wortel x} while (right(x) != NIL) do x = right(x); return x; Zoeken van Maximum 47 65 42 55 67 23 49 60 99 31 12 Maximum is meest rechtse knoop Tijd: O(h) met h hoogte van de boom

  8. Opvolger van knoop x: Als de rechter-deelboom van xniet leeg is, dan is de opvolger van x het minimum van die rechter-deelboom Als die wel leeg is dan zit die opvolger NIET onder x … Tree-Successor(x) if (right(x) != NIL) then return Tree-Minimum(right(x)) else … Opvolgers en voorgangers I x

  9. Stel x heeft lege rechter-deelboom Ga omhoog de boom in, zolang je in rechterdeelbomen zit Dus je gaat “links-omhoog” Daarna ga je nog 1 keer een stap omhoog Tree-Successor(x) if (right(x) != NIL) then return Tree-Minimum(right(x)) y = parent(x); while (y != NIL and x == right(y)) do x = y; y = parent(y); return y; Opvolger die niet onder x zit

  10. Tree-Successor(x) if (right(x) != NIL) then return Tree-Minimum(right(x)) y = parent(x); while (y != NIL and x == right(y)) do x = y; y = parent(y); return y; Tree-successor 40 15 65 8 55 17 67 7 10 29 49 60 99

  11. Lineair in de hoogte • Alle operaties: Search, Minimum, Maximum, Successor, Predecessor kunnen in O(h) met h de hoogte van de boom • Er bestaan zoekbomen met hoogte O(lg n), bijvoorbeeld neem een complete binaire boom • Later zien we hoe we logaritmische diepte kunnen handhaven

  12. Veel andere queries • Er zijn veel andere vragen die snel beantwoord kunnen worden mbv een binaire zoekboom • Voorbeeld: • Geef in volgorde alle keys die £k zijn voor een gegeven k (k hoeft niet zelf in de boom te zitten)

  13. Geef in volgorde alle keys die £k zijn voor een gegeven k (k hoeft niet zelf in de boom te zitten) Idee: recursief algoritme: vergelijk k met waarde van wortel en ga dan in recursie in de delen waar dat nodig is … Roep aan: ListKG(root.T, k) ListKG(node x, sleutel k) if (x == NIL) then Doe niets else if key(x) £k then ListKG(left(x)); Druk af key(x); ListKG(right(x)) else ListKG(left(x)) Code voor voorbeeld

  14. Correct, want … In goede volgorde want inorder! Let op rol van NIL’s Tijd: O(r + h) als we r antwoorden rapporteren en de boom hoogte h heeft ListKG(node x, sleutel k) if (x == NIL) then Doe niets else if key(x) £k then ListKG(left(x)); Druk af key(x); ListKG(right(x)) else ListKG(left(x)) Analyse voorbeeld

  15. Invoegen en weglaten • Invoegen: • Nieuwe knopen kunnen we altijd als bladtoevoegen • Het algoritme zoekt een goede plek op waar de nieuwe key als blad kan worden toegevoegd • Weglaten is wat moeilijker (straks)

  16. Tree-insert voegt een knoop altijd toe in een blad (NIL-knoop) We lopen eerst naar beneden in de boom en zoeken een blad Dat blad zit vlakbijz Tree-Insert(T,z) {z is een knoop met left(z) == right(z) == NIL} y = NIL; x = root(T); while (x != NIL) do y = x; {y is steeds de ouder van x} if (key(z) < key(x)) thenx = left(x) else x = right(x) {x is een blad van de boom “vlakbij” key(z)} … en dan … Invoegen

  17. 40 15 65 8 55 17 67 12 7 10 29 49 60 99 40 15 65 8 55 17 67 7 10 29 49 60 99 12

  18. Als we ‘t blad gevonden hebben hangen we z onder y Als y == NIL: de boom was eerst leeg Anders kijk je of je z links of rechts onder y moet hangen Tree-Insert(T,z) y = NIL; x = root(T); while (x != NIL) do y = x; if (key(z) < key(x)) thenx = left(x) else x = right(x) parent(z) = y; if (y == NIL) then root(T) = z (T lege boom) else if (key(z) < key(y) then left(y) = z else right(y) = z Invoegen - II

  19. Weglaten • Weglaten: als je een blad weglaat: makkelijk • Anders: je kan de knoop niet zomaar weglaten, dan krijg je een gat • Verplaats een andere knoop naar het ontstane gat: welke? • Later: herbalanceren 15 ? 17 7 10 29

  20. Weglaten • Bekijk verschillende gevallen: • Knoop heeft geen kinderen (makkelijk) • Knoop heeft alleen linkerkind • Knoop heeft alleen rechterkind (net zo als vorige geval, maar gespiegeld) • Knoop heeft zowel linkerkind als rechterkind

  21. 1e geval: knoop heeft geen kinderen Dan kan je de knoop gewoon weglaten Ouder van z krijgt een pointer naar NIL erbij Tree-Delete(T,z) {z is een knoop in de boom T} if (left(z)==NIL and right(z) == NIL) then if (parent(z) == NIL) then T = NIL {z was de enige knoop, de boom is nu leeg} elseif (left(parent(z))== z) thenleft(parent(z)) = NIL else right(parent(z)) = NIL Gooi knoop z weg Weglaten: geval 1 15 15 8 8 17 17 7 29 7 10 29

  22. Geval 2a: z heeft maar 1 kind, zeg een linkerkind en een ouder Dan hangen we dat kind van z direct onder de ouder van z … if (left(z) != NIL and right(z) == NIL and parent(z) != NIL) then x = left(z); if (z == left(parent(z)) then left(parent(z)) = x parent(x) = parent(z); Gooi z weg else right(parent(z)) = x; parent(x) = parent(z); Gooi z weg Weglaten – geval 2a 15 15 17 8 17 7 29 7 29 z is niet de wortel

  23. z heeft alleen een linkerkind, geen rechterkind, maar ook geen ouder (is de wortel) Dan laten we z weg, en wordt het linkerkind de wortel van T if (left(z) != NIL and right(z) == NIL and parent(z) == NIL) then T = left(z); Gooi z weg Geval 2b z is de wortel 42 15 15 8 17 8 17 7 29 7 29

  24. Als z alleen een rechterkind heeft gaat e.e.a. net zo als geval 2 (2a en 2b), met links en rechts verwisseld if (left(z) == NIL and right(z) != NIL) … Weglaten 3 17 29

  25. Laatste geval: z heeft twee kinderen Veel lastiger! Let op: hier verschillen CLRS 2e druk en CLRS 3e druk (en later) Idee: vind de opvolger van z en verplaats die naar de plek van z Weglaten 4 15 8 37 20 7 39 20 8 37 7 39

  26. Lemma. Als z twee kinderen heeft, dan heeft de opvolger y (successor) van z geen linkerkind Bewijsidee. Stel dat x een linkerkind is van y. Dan kan je laten zien dat z < x < y en dus is y niet de opvolger van z, tegenspraak. QED Weglaten – een nuttig lemma z right(z) y x

  27. Laat y de opvolger zijn van x Geval 4-1: y is het rechterkind van x Geval 4-2: y is niet het rechterkind van x Weglaten: twee subgevallen x 20 y 8 37 7 39 x 15 y 8 37 20 7 39

  28. We laten x weg y is het de opvolger van x Stel y is het rechterkind van x We verplaatsen de node van y naar de plek van x Goed zetten: Pointer van ouder van x naar x gaat nu naar y Linkerkind van x wordt linkerkind van y Als x de wortel was, wordt y de wortel Weglaten: geval 4-1 (y rechterkind x) x 20 y 8 37 7 39 y 20 37 8 39 7

  29. y = successor(x); if (parent(y) == x) then: if (parent(x) == NIL) then: {wortel} Root(T)=y if (parent(x) != NIL and left(parent(x)==x) {x is linkerkind} left(parent(x) = y parent if (parent(x) != NIL and right(parent(x)==x) {x is rechterkind} right(parent(x) = y … Weglaten: geval 4-1 (y rechterkind x) x 20 y 8 37 7 39 y 20 37 8 39 7

  30. … parent(left(x))= y left(y) = left(x) parent(y) = parent(x) {Rechterkind van y blijft hetzelfde} {Nu kan x weggegooid} Weglaten: geval 4-1 (y rechterkind x) x 20 y 8 37 7 39 y 20 37 8 39 7

  31. y wordt verplaatst naar positie van x Rechterboom van y komt op plek van y Weglaten: geval 4-2 (y niet rechterkind x) x 15 y 8 37 20 7 39 29 y 15 20 8 37 7 29 39

  32. Stap 1: pointers van en naar de ouder is net als geval 4-1 • Oldparenty = parent(y) • if (parent(y) == x) then: • if (parent(x) == NIL) then: • {wortel} • Root(T)=y • if (parent(x) != NIL and left(parent(x)==x) • {x is linkerkind} • left(parent(x)) = y • parent • if (parent(x) != NIL and right(parent(x)==x) • {x is rechterkind} • right(parent(x)) = y

  33. {links net als 4-1} left(y) = left(x) parent(left(x))= y {rechterkind van y nu goed zetten:} w = right(y) parent(w) = oldparenty left(parent(w))=w right(y) = right(x) parent(right(y))=y Daarna linker en rechterkinderen x 15 y 8 37 20 7 39 29 y 15 20 8 37 7 29 39

  34. Opmerking • De code in het boek is • Compacter • Moeilijker te snappen dat het correct werkt • Werkt in ongeveer dezelfde tijd

  35. Tijd • Alle operaties: zoeken, invoegen, weglaten, minimum, maximum opvolger, voorganger, kunnen in O(h) tijd, met h de hoogte van de binaire zoekboom • Verschillende andere operaties kunnen in O(n) tijd, zie ook werkcollege: • Opsommen van knopen in gesorteerde volgorde • … • Hoe groot kan h zijn?

  36. Beste geval: plm. lg n (complete binaire boom) Slechtste geval: n (elke knoop heeft maar 1 kind) Hoe groot kan h zijn?

  37. Gebalanceerde bomen • Extra werk bij invoegen en weglaten om te zorgen dat de hoogte van de boom O(log n) blijft • Veel verschillende oplossingen hiervoor. Wij bekijken een elegante vorm: de rood-zwart-bomen (red-black trees) en varianten

More Related