Optuigen van datastructuren Datastructuren Onderwerp 11

Vandaag 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

Hint voor programmeeropgave 3 Programmeeropgave 3: volgende en vorige: moeten ook werken als key niet in de structuur zitten, dus wellicht iets anders doen dan Successor en Predecessor?

Eerste voorbeeld: zoeken op twee keys Stel, we hebben stel objecten met twee soorten keys (bijvoorbeeld: naam en registratienummer). We willen snel kunnen zoeken op elk van de twee soorten keys, gevonden objecten kunnen weglaten, etc. Delete1(“Introduction to Algorithms 2nd edition”) Delete2(“ ”) Je kan 2 zoekbomen (of hash-tabellen of …) gebruiken; elk object in beide datastructuren opslaan, maar hoe zorg je dat deletions goed gaan?

Datastructuur Twee hash-tabellen met chaining, maar Dubbel-gelinkte lijsten (om snel iets uit de lijst weg te kunnen laten) Elk object heeft kopie in andere tabel en pointer naar kopie Variaties mogelijk Bespaar geheugen: sateliet-data maar op 1 plek Geen pointers, maar “gewoon” zoeken en deleten in de andere tabel Operaties gaan in O(1) verwachtte tijd onder aannames: Simple uniform hashing aanname Loadfactor n/m=O(1) 5,4 Allerlei pointers zijn niet getekend in dit voorbeeld Allerlei pointers zijn niet getekend in dit voorbeeld Slaan we over in 2010

Zoekbomen met extra pointers! 42,5 23,8 12,4 31,6 23,8 42,5 12,4 31,6 Alle operaties in O(log n): Gebruik rood-zwart bomen Bij deletion: ook weglaten in kopie; opletten dat alle pointers goed blijven staan Kan ook met hashtabellen…

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. Vb: als we keys 3, 6, 8, 10, 20 hebben, dan OS-Select(…, 4) = 10 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 Vb. Als we keys 3, 6, 8, 10, 20 hebben, dan OS-Rank(T,3) = 1, OS-Rank(T,10) = 4, etc. We gaan een zoekboom (evt. rood-zwart) aanpassen zodat deze operaties ook snel (O(h), O(log n)) kunnen

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

Bijhouden van deze gegevens size(x): integer die aantal keys in deelboom: x en alle afstammelingen van x Invariant: size(x) = size(left(x))+ size(right(x)) +1 waarbij deze waarden 0 zijn voor NIL’s Bij weglaten, rotaties, invoegingen: Herbereken de waarden voor de knopen waar we iets veranderden, en alle knopen naar het pad naar de wortel toe x

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

Selectie OS-Select(x, i): zoek het element met rang i in de deelboom met x als wortel Roep dit aan met OS- Select(root(T),i) Kijk naar het formaat van de linkerboom, zitlinks Dat vertelt of: Het gezochte element in de linkerboom zit OF De root het gezochte element is Het gezochte element in de rechterboom zit Er zijn al zitlinks + 1 kleinere elementen niet in de rechterboom OS-Select(x,i) 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 + 2) then) Return OS-Select( right(x), i – zitlinks – 1 )

Voorbeeld: zitlinks(root(T),9)

Tijd Selectie kan, als we size’s bijhouden, in O(log n) tijd op een rood-zwart-boom

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 (welke???): alle knopen in de linkerdeelboom van z

Welke knopen tellen 1 voor x zelf Alle knopen in de linkerdeelboom van x Sommige voorouders z van x en voor sommige voorouders z van x: alle knopen in de linkerdeelboom van z Voor alle knopen y die NIET de wortel zijn, tel je z=p(y): 1 Alle knopen in de linkerdeelboom van z z y x z y x

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

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

Andere evaluaties Er zijn ook andere functies die je op een soortgelijke manier kan bijhouden

Stelling Stelling Stel f is een waarde van 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. 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.

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) Rood-zwart-bomen: O(log n) Maar, je kan rood-zwart- bomen “verbeteren” zodat het in O(1) kan: Houd voor elke knoop een pointer naar z’n opvolger bij

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

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) Andere 2 stappen: kopieren van gegevens en rotaties zijn net zo makkelijk 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

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 Toepassingen… y x y x y x

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

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

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: 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

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

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 … x y y Geval 2: Geval 1:

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

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

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.

Conclusies Door toevoegen van extra informatie of pointers kan je soms Operaties op een datastructuur versnellen Extra functionaliteit toevoegen We zagen met name een optuigingen van rood-zwart- bomen die een aantal operaties in O(log n) of minder doen. E.e.a. kan ook met andere soorten gebalanceerde bomen. Goed ontwerp is combinatie van: toepassen van technieken, inventiviteit, en doorzettingsvermogen Analyse doe je door: wiskundige analyse EN experimenten