1 Optuigen van datastructuren 2 Dynamische order statistics (2)

2 Dit verhaal –Optuigen van datastructuren: door het bijhouden van extra gegevens en/of het hebben van extra pointers kan je Extra functionaliteit bieden Sommige operaties sneller doen –We zagen al eerder: Meerdere sleutels Rang, “hoeveel met waarde in bepaald gebied” –Nu: Andere queries Intervalbomen

3 Dynamische order statistics Extra operatie 1 op zoekboom (OS-Select): –Voor i, 1  i  n: wat het i de qua grootte in de datastructuur? Als i = 1, dan is dit het minimum Als i = n, dan is dit het maximum Als i = n/2, dan heet dit de mediaan We zoeken het element met rang i. Extra operatie 2 op zoekboom (OS-Rank): –Gegeven een key x die in de zoekboom T staat, wat is de rang van x, d.w.z., het hoeveelste element qua grootte is het Dit kan in O(log n) op rood-zwart (of AVL)-boom

4 Extra gegevens in zoekboom Elke knoop x heeft nog 1 extra getal opgeslagen: het aantal keys in het deel van de boom met x als wortel

5 Bijhouden van deze gegevens size(x): hoeveel afstammelingen (x inclusief) heeft x (aantal (niet-NIL) knopen in deelboom met x als wortel) (altijd integer) Invariant: –size(x) = size(left(x))+ size(right(x)) +1 –waarbij deze waarden 0 zijn voor NIL’s Bij veranderingen aan de boom: –Herbereken de waarden voor de knopen waar we iets veranderden, en alle knopen naar het pad naar de wortel toe x

6 Operaties in rood-zwart-boom Als we een knoop x weglaten: –Herbereken de size-waarden voor x en alle knopen op het pad van x naar de wortel –Steeds -1 Als we een knoop x toevoegen: –Zet size x op 1, en herbereken de size-waarden voor alle knopen op het pad van x naar de wortel –Steeds +1 Als we een rotatie doen: –Herbereken de size-waarden voor de twee geroteerde knopen en alle knopen op het pad van deze twee knopen naar de wortel Bij een rood-zwart-boom zijn er O(log n) knopen die: –Geroteerd, weggelaten, toevoegd zijn, –Of op het pad zitten van zo’n knoop naar de wortel Herbereken (van beneden naar boven) voor deze O(log n) knopen Bijhouden kan in O(log n) tijd per operatie

7 Selectie OS-Select(x, i): zoek het element met rang i in de deelboom met x als wortel Kijk hoeveel links zitten: je weet of je links of rechts moet zoeken en als je rechts gaat weet je dat je het i-zitlinks-1 e element daar moet hebben OS-Select(x,i) {Werkt correct als 1  i  size(x)} if left(x)==NIL then –zitlinks =0 else –zitlinks = size(left(x)) if (i  zitlinks) then –Return OS-Select(left(x),i) if (i = = zitlinks+1) then –Return x (if (i > zitlinks + 1) then) –Return OS-Select( right(x), i – zitlinks – 1 )

8 Voorbeeld: zitlinks(root(T),9)

9 Bepalen van de rang OS-Rank(T,x) geeft 1+ het aantal elementen in T dat kleiner is dan x. –Iets preciezer: als we gelijke keys kunnen hebben moeten die elementen voor x komen in een inorder-traversal Welke knopen moeten we tellen? –1 voor x zelf –Alle knopen in de linkerdeelboom van x –Sommige knopen die voorouder zijn van x: welke??? … –Voor sommige voorouders z van x alle knopen in de linkerdeelboom van z: welke?? …

10 Bepalen van de rang OS-Rank(T,x) geeft 1+ het aantal elementen in T dat kleiner is dan x. –Iets preciezer: als we gelijke keys kunnen hebben moeten die elementen voor x komen in een inorder-traversal Welke knopen moeten we tellen? –1 voor x zelf –Alle knopen in de linkerdeelboom van x –Alle voorouders z waarvoor x in de rechterdeelboom van z zit EN van al die knopen z alle knopen in de linkerdeelboom van z x is groter dan al die voorouders En kleiner dan alle andere knopen die we niet tellen…

11 Pseudocode OS-Rank(T,x) if left(x)==NIL then –totaal = 1 {alleen x} else –totaal = size(left(x))+1 {x en alles in linkerboom van x} while (y != root(T)) do –if y == right(p(y)) {y is een rechterkind} then if left(p(y)) == NIL then totaal++ {tel p(y)} else totaal = totaal + size(left(p(y))) + 1 –{p(y) en alles in de linkerdeelboom van p(y)} –y = p(y) {een stapje omhoog de boom in} Return totaal

13 Zoeken van aantal Aantal(T,k): hoeveel knopen in T hebben key precies k? Wat je kan doen is: –Pas zoeken aan, en vindt de “meest linkse” node x met waarde k –Bereken de rang i van k –Pas zoeken aan, en vindt de “meest rechtse” node y met waarde k –Bereken de rang j van k –Output: j – i

14 Tijd Bijhouden van alle gegevens kan in O(hoogte) = O(log n) tijd: Als we rotatie / invoeging / weglating doen: –Herbereken voor alle knopen op pad naar de wortel boven en inclusief geroteerde knopen: –O(log n) herberekeningen = O(log n) tijd

15 Andere evaluaties Er zijn ook andere functies die je op een soortgelijke manier kan bijhouden Algemene stelling Voorbeeld Intervalbomen

16 Stelling Stelling Stel f kent een waarde toe aan elke knoop van een rood-zwart-boom T met n knopen. Stel dat we f(x) kunnen uitrekenen aan de hand van de informatie in knopen x, left(x), right(x) en dus ook f(left(x)) en f(right(x)). Dan kan je f bijhouden gedurende insertions en deletions op T zodat elke operatie nog steeds O(log n) tijd kost. Ook voor AVL Ook voor AVL

17 Bewijs van Stelling Bewijs Bij elke insertion en deletion worden O(log n) knopen beinvloed door weglaten, toevoegen, kopieren van gegevens of roteren, of op het pad van zo’n knoop naar de wortel liggen. Voor deze knopen, herberekenen we f. Dit doen we in volgorde van beneden in de boom naar boven. Alle andere knopen blijven dezelfde waarde voor f houden.

18 Voorbeeld Uit wetenschappelijk onderzoek (van Dijk, Utrecht, 2011): Keys hebben een Boolean en staan aan of uit Extra operaties: –ZetAan(k): Zet key k aan –ZetUit(k): Zet key k uit Query Q: voor key k, wat is de som van alle keys die  k zijn en aan staan?

19 Voorbeeld (vervolg) Elke operatie in het voorbeeld kan in O(log n) tijd Wat houden we bij per knoop in de zoekboom?

20 Extra variabelen In elke knoop x van de zoekboom hebben we twee extra variabelen –Natuurlijk een Boolean staatAan (die aangeeft of de opgeslagen key aan of uit is) –En een variabele totaalAan: het totaal van alle keys die zitten in de deelboom met x als wortel en die aan staan –In code neem ik aan dat we, als in boek, een algemene NIL-knoop hebben met totaalAan=0

21 Bijhouden kan in O(log n) tijd staatAan is duidelijk totaalAan: vanwege Stelling –if x is NIL-knoop dan totaalAan(x)=0 –if staatAan(x) then totaalAan(x) = totaalAan(left(x))+totaalAan(right(x))+key(x) –if not(staatAan(x)) then totaalAan(x) = totaalAan(left(x))+totaalAan(right(x)) We kunnen de stelling toepassen

22 Query: recursieve methode die totaalAan gebruikt Roep aan met Q(root(T),k) Q(x,k) –{Geeft de som van alle keys in deelboom met wortel x die aan staan en  x zijn} –If x is een NIL-knoop then return 0 –If key(x)  k then if staataan(x) then hulp = key(x) else hulp = 0; Return totaalAan(left(x))+hulp+ Q(right(x),k) –Else return Q(left(x),k) O(log n) tijd voor de query –want 1 keer in recursie, dus O(hoogte)

23 Verbeteren met extra pointers: opvolgers Stel, we willen de opvolger van een knoop snel weten. (Allerlei toepassingen, bijv. we zoeken op naam, en willen mensen met dezelfde naam ook) We weten: O(h) en dus als we een gebalanceerde boom gebruiken O(log n) Maar, je kan deze bomen “verbeteren” zodat het in O(1) kan: –Houd voor elke knoop een pointer naar z’n opvolger bij

24 Bijhouden successor-pointers Voor elk van de elementaire operaties: –Toevoegen –Weglaten –Roteren –Kopieren van gegevens Zorgen we dat de pointers na afloop van zo’n operatie weer goed staan En dat e.e.a. in O(log n) tijd per elementaire operatie kan 1.Weglaten van knoop x –Bereken predecessor x, zeg y –Successorpointer van x wijst naar z –Laat de successorpointer van y naar z wijzen

25 Elementaire operatie 2: toevoegen van knoop Toevoegen in O(log n): –Voeg de knoop x eerst toe –Bereken predecessor x, zeg y –Stel successor-pointer van y wijst naar z –Laat successorpointer van y naar x wijzen –Laat successorpointer van x naar z wijzen Merk op: balanceer-acties nog niet gedaan, maar de diepte van de boom is hooguit 1 te groot daardoor (dus nog steeds O(log n))

26 Andere stappen en stelling Andere twee stappen: verplaatsen van een knoop in de boom en rotaties zijn net zo makkelijk –Vaak hoef je hiervoor niets te doen: pointers “worden meegedragen” Stelling: Rood-zwart-bomen hebben een variant, waarbij insertions, deletions, search in O(log n), maar successor, predecessor, minimum, maximum in O(1) tijd gaan

27 Intervalbomen Een rood-zwart-boom waarbij alle keys intervallen zijn. Hier: gesloten intervallen (eindpunten horen erbij): [a,b] Open en half-open intervallen gaan op soortgelijke manier Interval [a,b]: object, met –low(x) = a (lage, of linker-eindpunt) –high(x) = b (hoge, of rechter-eindpunt) Operaties op intervalboom: –Invoegen, Weglaten –Interval-Overlap-Search(T, y) Lever een pointer naar interval-object x, zodat interval x interval y overlapt, of NIL als zo’n x niet bestaat (overlap = niet-lege doorsnede) Toepassingen… y x y x y x

28 Datastructuur Gebruik rood-zwart-boom met een knoop voor elk opgeslagen interval, waarbij het linkereindpunt de key is Verbeter de boom als volgt: –Elke knoop x heeft een waarde max(x): –max(x) = de maximum waarde van een rechtereindpunt van een interval opgeslagen in de boom met x als wortel [6,8] 16 [7,16] 16 [4,8] 15 [3,15] 15 [4,9] 10 [4,5] 5 [6,10] 10

29 Bijhouden van max(x) max(x) = maximum van –high(x), –max(left(x)), en –max(right(x)) Dus stelling geldt: O(log n) per insertion en deletion

30 Uitrekenen van Interval-Search Als we de max-waarden hebben, kan de Interval-Search in O(log n) tijd gedaan worden Stel we zoeken interval y. Kijk naar wortel x: –Als y overlapt met [low(x),high(x)]: klaar, we leveren de wortel op –Als x == NIL: klaar, niets gevonden –Anders zoeken we links OF rechts Maar hoe zien we dat?

31 Links of rechts? –Stel x is niet NIL en intervallen van x en y overlappen niet –Als max(left(x))  low(y), dan x = left(x) Als er een oplossing is, dan zit er zo’n oplossing in de linkerboom: het stuk met wortel left(x). Dit bewijzen we zometeen –Anders: doe x = right(x) Als er een oplossing is, dan zit er zo’n oplossing in de rechterboom x x y y of

32 Pseudocode Interval-Search(T,y) x = wortel(T); while x != NIL do –if het interval van x overlapt het interval van y then Return x –if left(x) != NIL and max(left(x))  low(y) then x = left(x) –else x = right(x) Return NIL

33 Lemma en begin bewijs Stel x is een knoop in de rood-zwart-boom, zodat er een z is die y overlapt, en z is een afstammeling van x. Stel x en y overlappen niet. Als left(x)!=NIL en max(left(x))  low(y), dan is er een afstammeling van left(x) die y overlapt. Bewijs. Er zijn 2 gevallen die we bekijken. x en y overlappen niet, dus: x helemaal links van y of x helemaal rechts van y … xy y Geval 2: Geval 1: x

34 Geval 1 Kijk naar het interval w, afstammeling van left(x), met high(w) = max(left(x)). Die bestaat (definities.) low(w)  low(x), want w in linkerdeelboom van x (zoekboomeigenschap) high(w)  low(y) volgt uit max(left(x))  low(y) Dus: w begint voor x en eindigt na het begin van y, dus w overlapt y: klaar x y

35 Geval 2 Kijk naar een oplossing z die met y overlapt. z moet beginnen voordat y eindigt, dus –low(z)  high(y) < low(x) Dus moet z in de linkerdeelboom van x zitten, vanwege zoekboomeigenschap. QED x y

36 Samenvatten van correctheid algoritme Als er een oplossing is, dan is er een oplossing in de linkerdeelboom als left(x)!=NIL en max(left(x))  low(y). Een soortgelijk argument toont aan: als die test niet geldt, en er is een oplossing, dan is er een oplossing in de rechterdeelboom Invariant van het algoritme: als er een oplossing is, dan is er een oplossing in de deelboom met x als wortel. Dus: je vindt de oplossing als ie bestaat.

37 Conclusies We hebben een aantal verschillende manieren gezien om zoekbomen (rood-zwart of anders) te verbeteren Allerlei operaties kunnen snel met behulp van zoekbomen Kwestie van: creativiteit, toepassen van technieken, experimenteren, … Een andere datastructuur waarmee je zo ongeveer hetzelfde kan zijn de skiplists –Probabilistisch –Makkelijker implementatie (denk ik) –Verwachte tijd O(log n)