Datastructuren Zoekbomen

Presentatie over: "Datastructuren Zoekbomen"— Transcript van de presentatie:

1 Datastructuren Zoekbomen
Deel 1 Bomen Doorlopen Eenvoudiger operaties

2 Dit onderwerp Bomen: terminologie Bomen: datastructuur voor bomen Zoekbomen: hoe zoek ik in bomen Volgende keer: hoe voeg ik knopen toe en haal ik knopen weg uit zoekbomen (efficient)

3 Gewortelde boom (rooted tree) Knopen van boom: node Wortel (root)
Terminologie I Gewortelde boom (rooted tree) Knopen van boom: node Wortel (root) Voorouder (ancestor) Knoop op pad van x (inclusief) naar wortel Afstammeling (descendant) Proper ancestor; proper descendant Voorouder of afstammeling maar niet x zelf Ouder (parent) Kind (child)

4 Terminologie II Sibling: knopen met dezelfde ouder (broers) Blad (leaf) Interne knoop (internal node) a b c d e Vb van siblings f g

5 Terminologie III: graad
De graad van een knoop is het aantal kinderen NB: Anders dan in grafen!! Vb. hiernaast Knoop is blad, desd als graad 0 2 1

6 Terminologie IV: hoogte en diepte
Diepte (depth): lengte van pad van x naar de wortel Hoogte (height): maximum lengte van pad van knoop naar een blad onder de knoop 1 1 2 2 dieptes 3 3 3 2 1 hoogtes

7 Terminologie V: Geordende boom
Gewortelde boom met voor elke knoop een volgorde van zijn kinderen vastgelegd

8 Terminologie VI: Deelboom geworteld bij x
De deelboom geworteld bij x (subtree rooted at x) x

9 Een boom is een binaire boom, als
Binaire bomen Een boom is een binaire boom, als De boom leeg is (0 knopen heeft), OF Een wortel en een linkerdeelboom en rechter-deelboom heeft Die linker- en rechter-deelboom zijn weer binair Ze mogen dus ook leeg zijn Verschillende binaire bomen!

10 Twee manieren om binaire bomen te tekenen

11 Datastructuren voor gewortelde bomen
Nu bespreken we: Datastructuur voor binaire bomen Datastructuren voor gewortelde bomen met willekeurige graad We zagen al eerder een andere: heap Heeft speciale eigenschappen die maken dat we ‘m makkelijk in een array kunnen stoppen (Max- of Min-)Heap-eigenschap

12 Gewortelde bomen root[T] p Elke knoop x heeft drie pointers:
Naar de ouder Notatie: p[x], of p.x of parent.x of … Naar de linkerdeelboom (eventueel leeg) left-child Naar de rechterdeelboom (eventueel leeg) right-child Implementatie van leeg (hangt af van programmeertaal en wat je handig vindt): NIL En we hebben een verwijzing naar de wortel van de boom root[T] of wortel.T of root.T of … root[T] p left right

13 Datastructuur voor bomen met willekeurig aantal kinderen
Elke knoop heeft: Pointer voor de wortel Gelinkte lijst per kind (boek: enkelvoudig gelinkt. Soms nuttig om dubbelgelinkte lijst te maken) Pointer naar eerste kind Namen: p (parent, ouder) left-child right-sibling (rechterbroer / rechterzus)

14 Dynamische verzamelingen: Zoekbomen
Zoekboom: Datastructuur voor Dynamische verzamelingen (bijv. Dictionaries) Operaties die we kunnen doen op verzameling elementen: Search (zoek element op key-waarde, en geef opgeslagen extra informatie) Minimum (wat is de kleinste key-waarde) Maximum (…) Predecessor (Voorganger: gegeven x, wat is de grootste y<x die opgeslagen is) Successor (gegeven x, wat is de kleinste y>x die opgeslagen is) Delete (laat een key (met de extra informatie erbij) weg) Insert (voeg een key (en extra informatie) toe)

15 Verschillende implementaties
Als we “Predecessor” en “Successor” niet belangrijk vinden, is een Hash-tabel een heel goede, en heel veel gebruikte datastructuur Vandaag bekijken we de binaire zoekboom Wordt ook veel gebruikt

16 Binaire zoekboom 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 47 65 42 55 23 67 45 49 60 99 12 31

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

18 Binairy search-tree property
Als x een knoop is in een binaire zoekboom, en y is een knoop in de linkerdeelboom van x, dan is key[y] £ key[x]. Als x een knoop is in een binaire zoekboom, en y is een knoop in de rechterdeelboom van x, dan is key[x] £ key[y]. 10 20 5

19 Doorlopen van binaire boom
Drie manieren om een binaire boom te doorlopen: Inorder Som eerst de linkerboom op (recursief) Dan de wortel Dan de rechterboom (recursief) Preorder Som eerst de wortel op Dan de linkerboom (recursief) Postorder Som eerst de linkerboom (recursief) En tot slot de wortel op

20 Inorder-Tree-Walk(x)
if (x != NIL) then Inorder-Tree-Walk( left(x)) Print (key(x)) Inorder-Tree-Walk( right(x))

21 Preorder-Tree-Walk(x)
if (x != NIL) then Print (key(x)) Preorder-Tree-Walk( left(x)) Preorder-Tree-Walk( right(x))

22 Postorder-Tree-Walk(x)
if (x != NIL) then Postorder-Tree-Walk( left(x)) Postorder-Tree-Walk( right(x)) Print (key(x))

23 Eigenschappen Inorder-Tree-Walk
Somt van een binaire zoekboom de knopen op in niet-dalende volgorde Gebruikt Q(n) tijd op als we n knopen hebben Stel dat we k knopen in de linkerboom hebben Dan n-k-1 in de rechterboom T(n) = T(k) + T(n-k-1) + d voor constante d Geeft: T(n) = (c+d)n+c met c=T(0) (inductie)

24 Expressies en notatie * * + / 1 2 3 4 5
Gebruikelijke notatie voor expressies: (1+2)*(3*(4/5)) Infix-notatie * * + / 1 2 3 4 5

25 Expressies en notatie II
Infix: (1+2)*(3*(4/5)) Reverse Polish Notation Postfix-notatie: / * * Geen haakjes nodig Uitgevonden door Poolse wiskundige Lukasiewicz Stack om e.e.a. uit te rekenen * * + / 1 2 3 4 5

26 Zoeken in binaire boom Als de key in de wortel zit: klaar
Anders: kijk of je in de linker- of rechter-deelboom moet zijn en ga in die boom in recursie Tree-Search(x,k) {Zoek naar key k in een boom met wortel x} if (x == NIL or k == key(x)) then return x if ( k < key(x)) then return Tree-Search(left(x),k) else return Tree-Search(right(x),k)

27 Zoeken in binaire boom Tree-Search(x,k) {Zoek naar key k in een boom met wortel x} if (x == NIL or k == key(x)) then return x if ( k < key(x)) then return Tree-Search(left(x),k) else return Tree-Search(right(x),k) 47 65 42 55 23 67 49 60 99 12 31

28 Niet-recursieve (uitgerolde) versie
47 Iterative-Tree-Search(x,k) while ( x != NIL and k != key(x)) do if ( k < key(x)) then x = left(x) else x = right(x) return x; 65 42 55 23 67 49 60 99 12 31 Doet hetzelfde, maar zonder recursie Meestal efficienter (in constante in O)

29 Tijd van Tree-Search Zowel recursieve als iteratieve versie gebruiken O(h) tijd, met h de hoogte van de boom Later: manieren om h = O(log n) te krijgen

30 Zoeken van Minimum Het minimum is altijd de “meest linkse” knoop
Sorry, geen grapjes over politiek hier Tree-Minimum(x) {Zoek het minimum in de boom met wortel x} while (left(x) != NIL) do x = left(x); return x;

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

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

33 Opvolger Opvolger van key x: Twee gevallen:
Kleinste van alle andere keys die groter is dan x Twee gevallen: De opvolger zit “onder” x De opvolger zit niet onder x

34 Opvolger Opvolger van key x: Twee gevallen:
Kleinste van alle andere keys die groter is dan x Twee gevallen: De opvolger zit “onder” x Als de rechterdeelboom van x niet leeg is! De opvolger zit niet onder x Als de rechterdeelboom van x wel leeg is…

35 Opvolgers en voorgangers I
Opvolger van knoop x: Als de rechter-deelboom van x niet 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)) y = parent(x); ???

36 Opvolger die niet onder x zit
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;

37 Tree-successor 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; 40 15 65 8 55 17 67 7 10 29 49 60 99 Zoek bijv opvolger 29

38 Voorgangers Vinden van voorganger (Tree-predecessor) gaat net zo (“gespiegeld”)

39 Conclusies 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 (of bijna complete) binaire boom

40 Samenvatting Terminologie Zoekbomen Operaties op zoekbomen Volgende keren: hoe voeg je knopen toe, en laat je knopen weg uit zoekbomen? En hoe zorg je dat een zoekboom lage diepte blijft houden?