Optuigen van datastructuren

Optuigen van datastructuren Zoeken op meerdere sleutels Dynamische order statistics (1)

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 Meerdere sleutels Dynamische order statistics

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(“0-262-03293-7”) • Je kan 2 zoekbomen (of hash-tabellen of …) gebruiken; elk object in beide datastructuren opslaan, maar hoe zorg je dat deletions goed gaan?

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) Datastructuur 5,4 5,4 Allerlei pointers zijn niet getekend indit voorbeeld

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

Dynamische order statistics • Extra operatie 1 op zoekboom (OS-Select): • Voor i, 1 £i£n: wat het ide 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 rangi. • 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

Elke knoop x heeft nog 1 extra getal opgeslagen: het aantal keys in het deel van de boom met x als wortel Extra gegevens in zoekboom 26 20 41 7 17 12 47 1 14 7 21 4 30 5 10 4 16 2 19 2 23 1 28 1 38 3 35 1 39 1 7 2 12 1 15 1 20 1 3 1

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

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) {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 ) Selectie

Randgevallen • Test of i in het goede interval zit: • if (1 £i£ size(x) then • … (code als net) • else return NIL

Voorbeeld: zitlinks(root(T),9) 26 20 41 7 17 12 47 1 14 7 21 4 30 5 10 4 16 2 19 2 23 1 28 1 38 3 35 1 39 1 7 2 12 1 15 1 20 1 3 1

Tijd • Selectie kan, als we size’s bijhouden, in O(h) tijd op een boom met diepte h • Straks zien we bomen met diepte O(log n) dus in O(log n) tijd

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?? • …

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 • Alle voorouders z waarvoor x in de rechterdeelboom van z zit • Want dan is x groter dan z • Voor deze voorouders z van x: alle knopen in de linkerdeelboom van z (die zijn allemaal kleiner dan z en dus kleiner dan x) • Verder niet…

1 voor x zelf Alle knopen in de linkerdeelboom van x Sommige voorouders z van x en voor die voorouders z van x: alle knopen in de linkerdeelboom van z De test: y = = right(p(y)) Waarbij y het kind van z is in de deelboom waar x in zit Tel dit omhooglopend in de boom! Welke knopen tellen 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

26 20 41 7 17 12 47 1 14 7 21 4 30 5 10 4 16 2 19 2 23 1 28 1 38 3 35 1 39 1 7 2 12 1 15 1 20 1 3 1

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 + 1 Zoeken van aantal 42 4 42 2 42 1 42 1 47 2 47 1 49 1

Andere evaluaties / Conclusies • Er zijn ook andere functies die je op een soortgelijke manier kan bijhouden • Een aantal hiervan behandelen we later, na het onderwerp van de gebalanceerde bomen • Dus eerst: hoe zorg je ervoor dat de diepte van de boom O(log n) blijft?? • Door toevoegen van extra informatie of pointers kan je soms • Operaties op een datastructuur versnellen • Extra functionaliteit toevoegen • Analyse gaat: wiskundig EN experimenteel

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 Verbeteren met extra pointers: opvolgers 17 Sheet komt in deel materiaal naRood-zwart-bomen 14 21 10 16 19 23 7 12 15 20 3

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 Weglaten van knoop x Bereken predecessor x, zeg y Successorpointer van x wijst naar z Laat de successorpointer van y naar z wijzen Bijhouden successor-pointers Sheet komt in deel materiaal naRood-zwart-bomen 14 14 10 10 7 12 7 3 3

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 Sheet komt in deel materiaal naRood-zwart-bomen

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… Sheet komt in deel materiaal naRood-zwart-bomen x y x y x y

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 Datastructuur [6,8] 16 Sheet komt in deel materiaal naRood-zwart-bomen [4,8] 15 [7,16] 16 [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 Sheet komt in deel materiaal naRood-zwart-bomen

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 Sheet komt in deel materiaal naRood-zwart-bomen

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 Sheet komt in deel materiaal naRood-zwart-bomen

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 Sheet komt in deel materiaal naRood-zwart-bomen y x Geval 1: Geval 2: … y

y x 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 Sheet komt in deel materiaal naRood-zwart-bomen

y Geval 2 x • 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 Sheet komt in deel materiaal naRood-zwart-bomen

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. Sheet komt in deel materiaal naRood-zwart-bomen

Conclusies Sheet komt in deel materiaal naRood-zwart-bomen • 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

Optuigen van datastructuren