Opgaven Abstracte Datastructuren Datastructuren, Werkgroep, 31 mei 2017. Gebruik deze opgaven, naast die uit het boek, om de stof te oefenen op het werkcollege. Cijfer: Op een toets krijg je meestal zes tot acht opgaven. 1. Verborgen Complexiteit in List: Gabriella maakt zich zorgen over verborgen geheugenen tijdgebruik in een List. De ongebruikte arraydelen kosten geheugen, en het periodiek overstapelen naar een nog grotere array kost tijd. Maak deze aannamen: (1) de array heeft lengte 1 in het begin; (2) bij een Add op volle array wordt een tweemaal zo grote aangemaakt en alles overgestapeld. (a) Bewijs de geheugen-optimaliteit: voor n keys wordt altijd O(n) geheugen gebruikt. (b) Geef een functie die de kosten van de j de Add beschrijft. (c) Bewijs de tijd-optimaliteit dat n Adds samen O(n) tijd kosten. (a) Zolang er 0 keys zijn is 1 geheugenplaats in gebruik. Het aantal geheugenplaatsen wordt pas verdubbeld, zeg naar 2S, wanneer S niet meer genoeg is, dus er zijn dan n > S keys. Hieruit volgt dat de lengte van de array, minder dan tweemaal het aantal keys bedraagt. (b) Zonder omstapelen kost het constante tijd (Add(x) is A[count++]=x;) dus O(1) als j 1 geen macht van 2 is. De arraygrootte is steeds een macht van 2 en als j een tweemacht plus 1 is, moet je de vorige j 1 elementen verstapelen in een nieuwe array, wat je O(j 1) kost, en dan nog O(1), dus samen O(j). (c) Het toevoegen zelf kost n maal O(1) dus O(n). Het overstapelen kost je steeds lineaire tijd bij een tweemacht, dus samen: lineair in de som van alle tweemachten kleiner dan n. De som van tweemachten is altijd minder dan de volgende tweemacht, dus in dit geval kleiner dan 2n zodat de kosten van het omstapelen ook O(n) zijn. (a) Het afgedankte geheugen wordt weer gerecycled, dus de oude array hoef je niet meer mee te tellen. Als je dat wel doet, gebruik je tot viermaal n geheugen. Vergelijk ook met een linked list: dan heb je n Nodes, elk met minstens een key en een pointer, dus ook al gauw tweemaal n geheugen (als key en pointer even groot zijn). De array is dus echt wel geheugen-goed ondanks de soms lege ruimte. (c) Een individuele Add kan dus wel duur zijn, maar een reeks van Adds kost constante tijd gemiddeld.
2. List met Removes: Remco wil de List structuur uitbreiden met Remove(i) maar wel zo dat het tijd- en geheugenoptimaal blijft; in Remco s toepassing is de volgorde van elementen niet belangrijk. (a) Hoe kun je de Remove(i) in O(1) tijd uitvoeren? (b) Waarom is de lijststructuur niet meer geheugen-efficient? (c) Remco besluit (naar analogie van de uitbreidingsregel) de array te halveren en over te stapelen wanneer hij voor minder dan de helft gevuld is. Waarom is het nu niet meer tijd-efficient? (d) Kun je de geheugen- en tijd-efficientie beredeneren met deze halveringsregel: halveer als de array minder dan kwartvol is. (a) Als de volgorde niet uitmaakt werkt: A[i] = A[--n];. Is de volgorde wel belangrijk, dan kun je A[j] niet zonder meer vervangen door het laatste element maar moet je alle volgende elementen opschuiven (lineaire tijd!). (b) Probleem is, dat na Removes, het aantal overgebleven elementen heel klein kan zijn, zodat de gebruikte geheugenruimte willekeurig groot kan zijn tov. het aantal keys. (c) De uitbreidingen en de inkrimpingen van de array zijn duur (ze kosten O(n) tijd), dus je moet zorgen dat ze zeldzaam zijn. Als je array halfvol is, zakt na een Remove de bezetting onder de helft, maar als je de array halveert is de nieuwe meteen vol (op 1 plek na). Na twee Adds is weer een verdubbeling nodig, en dan na twee Removes weer een halvering. Je kunt dus een reeks maken (steeds afwisselend twee Adds en twee Removes) waarin om de operatie Θ(n) tijd nodig is. (d) Dit is een uitstekend idee. Het geheugen dat je in gebruik hebt, kan tot viermaal het aantal keys zijn, maar dat is dus altijd O(n). Na een uitbreiding of inkrimping van de array is deze altijd ongeveer half vol. De volgende omstapelactie, die n keys omstapelt naar een nieuwe array, vindt ofwel plaats na minstens n Removes, danwel na minstens n/2 Adds. De kosten van een omstapeling zijn dus constant als je ze uitmiddeld over de updates sinds de vorige omstapeling. (a) Er staat dan nog data in de arrayplaatsen vanaf n. Dat hoeft niet erg te zijn maar je kunt het verwijderen met A[n] = nil;. Het onderwerp Amortisering wordt bij Algoritmiek nog wat systematischer uitgewerkt.
3. Verwijderen uit gelinkte lijst: In een doubly linked list heeft elke Node een key, prev en next. In een singly linked list ontbreekt de prev. (a) Geef een methode die Node y verwijdert uit een doubly linked list. (b) Geef een methode die Node y verwijdert uit een singly linked list. (c) Moet je y meegeven als ref parameter (zowel voor (a) als voor (b))? Leg uit! (a) Laat de voorganger van y wijzen naar de opvolger van y, en de opvolger naar de voorganger: y.prev.next = y.next; y.next.prev = y.prev;. Uitzonderingsgevallen af te handelen: als y de eerste of laatste Node is hoeft de aapassing van y.prev danwel y.next niet maar moet je misschien een externe pointer aanpassen. (b) Om dit te kunnen doen moet je y als ref argument geven. De methodeheader is dan void DelFirst(ref Node y) en in de methode gaat het als y = y.next;. (c) Zonder ref argument kun je in de singly linked niet bij de voorganger komen. In de doubly linked list kan dat wel en heb je y niet als ref nodig. (Je kunt wel de key en next van y s opvolger naar y kopiëren: y.key = y.next.key; y.next = y.next.next;. Dit kan natuurlijk niet als y de laatste knoop is.) Tot 3pt; 1 per deelvraag. Codes: GR = Bij (c) dat t niet nodig is, en je bij (b) de lineaire oplossing: toch punt. K = Nodes selecteren op basis van Key, 0pt. L = Oplossingen die superlineaire tijd kosten (bij b), 1/2pt. R = Bij (b) geen Ref gebruikt maar wel assignatie aan y, 0pt. Nog 1/2 terug te verdienen met argumentatie bij (c) dat die wel moet. U = De Uitzonderingsgevallen aan begin en einde van de lijst hoeven er niet bij voor puntentoekenning. V = Bij (c) moet je zien dat er Verschil is in deze situaties, dus je krijgt alleen een punt als je beide goed hebt, en niet een halve punt voor een goed. 4. Circulaire lijst: Zie boek Cormen, Opdracht 10.2-5. 5. Lijsten samenvoegen: Zie boek Cormen, Opdracht 10.2-6. 6. Lijsten omkeren: Zie boek Cormen, Opdracht 10.2-7. 7. Lijsten snel omkeren: Zie boek Cormen, Opdracht 10.2-8.
8. Snellere FruitPlanning: Download en probeer het PILletje FruitPlanner. (a) Wat is de asymptotische complexiteit (als functie van n) van de FruitPlanner? (b) Verbeter de complexiteit door voor elke nieuwe set, de vitamines in O(1) tijd te berekenen. (c) Het kan ook in O(n ( 2) n )! (a) O(n 2 n ) want je bekijkt 2 n deelverzamelingen, elk kost lineaire tijd om de som te berekenen. (b) Als je in de normale volgorde de sets afloopt, en steeds alle verschuivende vruchten bij- of aftelt, gebruik je geamortiseerd lineair veel operaties (zie Amortisering bij Algoritmiek). Je kunt ook de verzamelingen via een Gray-sequence doorlopen of recursief enumereren. (c) Verdeel de fruitverzameling in twee delen van omvang n/2, bereken van allebei de vitamines in alle mogelijke subsets, zoek links en rechts naar subsets met sum V. 9. Ref parameter en Sorted List: Download en bekijk het PILletje SList. (a) Programmeer een alternatieve Insert en een Delete zonder gebruik te maken van refargumenten. (b) Implementeer de Delete. (c) Voeg een ExtractMax toe. (d) Voeg een optie toe om de elementen in dalende volgorde af te drukken. (e) Vergelijk de snelheid van een recursieve en iteratieve implementatie. (a) Hier moet je met diverse speciale gevallen rekening houden, zoals dat het nieuwe element wel of niet kleiner is dan het eerste. (b) Met een ref parameter: als lijst leeg of eerste element groter dan deletekey kan het niet, als eerste key gelijk aan deletekey, vervang lijst door next, anders deleten op next. (c) De max staat achteraan, dus verwijder een Node waarvan de next op null staat. (d) Gaat ook recursief, maar je print eerst de sublijst en daarna het voorste element. Deze opdracht is een voorbereiding op het gebruik van ref parameters wat we straks bij bomen nog meer gaan doen.
10. Bitmap: Boris gebruikt een uint go om een deelverzameling van een collectie van 30 game-items op te slaan. De i de bit van go staat op true wanneer object i aanwezig is. (a) Geef een conditie die test of object i aanwezig is. (b) Geef een instructie die object i toevoegt aan go. (c) Geef een instructie die object i verwijdert uit go. Alle oplossingen moeten in O(1) tijd werken. (a) (((go >> i) & 1) > 0). (b) go = (1 << i);. (c) go &= ~ (1 << i);. Deze oplossingen werken allemaal met een klein aantal (circa drie) machine-instructies. A = Je gebruikt Aritmetische instructies, - en +, deze zijn iha. minder efficient dan bitoperaties en gaan fout als de bit in go niet de goede waarde heeft. Puntenaftrek!