Tweede Toets Datastructuren 28 juni 2017, , Educ-β.

Transcriptie

1 Tweede Toets Datastructuren 28 juni 2017, , Educ-β. Motiveer je antwoorden kort! Stel geen vragen over deze toets; als je een vraag niet duidelijk vindt, schrijf dan op hoe je de vraag interpreteert en beantwoord de vraag zoals je hem begrijpt. Cijfer: Elke vraag is 2pt. Cijfer T2 is totaal plus 0,5 gedeeld door 1,35. Maak vraag 1 en 2 op pagina 1, 3 en 4 op pagina 2, 5 en 6 op pagina 3 en vraag 7 op de achterkant. 1. Binaire Fruitmand: Floris gebruikt een uint fm om een deelverzameling van 30 fruitsoorten op te slaan. De i de bit van fm staat op true wanneer element i aanwezig is. (a) Geef een instructie die object i toevoegt (of niets doet als i er al is) in O(1) tijd. (b) Floris schrijft de instructie fm &= (~ 1) << i; om fruit i te verwijderen. Waarom klopt deze niet en hoe moet het wel? Oplossing: (a) fm = (1 << i);. (b) Als je de 1 eerst inverteert en dan i naar links shift, komen er achter de bedoelde 0 nog i nullen te staan. Gevolg is dat alle fruitstukken 0 t/m i verdwijnen. Je moet eerst shiften en dan inverteren, dus zo: fm &= ~ (1 << i);. Beoordeling/Toelichting: Per vraag 1pt. Beoordelingscodes: D = fm = ~ ( ~ fm (1 << i)) werkt natuurlijk ook, maar is vrij omslachtig wegens Dubbele negatie. E = Fruit nummeren vanaf Een en bits vanaf 0 is onlogisch. N = ~ 1 is niet 0 (maar 2). P = De instructie fm += (1 << i); gaat mis als i al aanwezig is. Kost halve punt evenals verwijderen met -. T = Test if (fm & (1<<i) == 0) is overbodig. X = Xor is minder goed want doet het omgekeerde als de bit al goed staat.

2 2. Stack met Pointers: Een pointer-implementatie van de stack bevat in elke node een stack-element en een pointer naar een andere node (evt. null). (a) Als de Node met element x een pointer naar de Node met y heeft, is x dan eerder of later dan y toegevoegd aan de stack? Waarom? (b) Geef de naam en pseudocode van de methode die element z toevoegt aan de stack. Oplossing: (a) Nodes in een stack hebben pointers naar oudere knopen, dus in dit geval is x later toegevoegd. (b) void Push(T z) { top = new Node(z, top); } is al genoeg als de constructor voor Node deze twee argumenten invult als key en next. Beoordeling/Toelichting: Per deelvraag een punt, totaal 2. Codes: A = Implementaties in Array (of List) zijn niet goed. B = y moet wel ouder zijn want anders kan x geen pointer hebben is een onjuist argument, immers in een Queue hebben nodes juist wel een pointer naar nieuwere nodes, dus het kan wel. C = Je moet een node creëren, het argument van Push is immers een key en geen node. P = Dat toevoegen Push heet moet je weten. 3. Twee, Acht, Log en Wortel: Geef de asymptotische oplossing van (a) W (n) = 2.W (n/4) + 2 lg n, (b) X(n) = 8.X(n/4) + n n, en geef aan hoe je eraan komt. Oplossing: Dit kan allemaal met de Master Theorem. (a) Uitkomst is hier W (n) = Θ( n). Je hebt a = 2 en b = 4 dus b log a = 1 2. En f(n) = 2n 0 lg n, met macht 0 van n dus van polynomiaal lagere orde dan n 1/2. (b) Uitkomst is X(n) = Θ(n n lg n). Met a = 8 en b = 4 is b log a = 3/2, dezelfde macht als de dwangterm. Dus extra log. Beoordeling/Toelichting: Een pt per goed antwoord. Het is in alle gevallen gerechtvaardigd om het antwoord als Θ te schrijven, maar een O scoort ook.

3 4. Heap: De rij A = [12, 15, 20, 19, 17, 32, 26, 23, 21, 18, 20] is een MinHeap. Zeg stap voor stap wat er gebeurt, en geef de heap na afloop, bij: (a) Insert(18) op heap A; (b) ExtractMin() op heap A. Oplossing: (a) Er zijn eerst 11 keys en de 18 wordt op plek 12 gezet, waarna Rootify(12) wordt aangeroepen. Hij is kleiner dan zijn parent 32, ze wisselen dus en Rootify(6). Weer is 18 kleiner dan zijn parent 20, dus hij wisselt en Rootify(3). Maar 18 is nu keurig groter dan zijn parent en het is klaar. De heap nu: [12, 15, 18, 19, 17, 20, 26, 23, 21, 18, 20, 32]. (b) Bij extractmin wordt A[1], dus 12, verwijderd en bewaard om opgeleverd te worden. De plek wordt opgevuld met de laatste key, 20, en Heapify(1). Die 20 wisselt met kleinste kind 15, en Heapify(2). De 20 wisselt met 17 en Heapify(5). De 20 wisselt met kind 18 en klaar. Resultaat [15, 17, 20, 19, 18, 32, 26, 23, 21, 20]. Beoordeling/Toelichting: Per deelvraag een punt. Beoordelingscodes: H = Je moest de eind Heap geven en die ontbreekt. I = Argument van Heapify en Rootify is een index, niet een key. L = Na de extractmax hoort het Laatste element 20 niet meer bij de heap, al zit het er fysiek misschien nog in. N = Als je (b) NA (A) doet gebeurt dit: De plek wordt opgevuld met 32, en Heapify(1). Hierin wisselt 32 met z n kleinste kind 15, plus Heapify(2). Weer wisselt 32 met kleinste kind, 17, plus Heapify(5). Weer wisselt 32 met kleinste kind, 18, plus Heapify(10). Hieronder geen kinderen dus klaar. Heap nu: [15, 17, 18, 19, 18, 20, 26, 23, 21, 32, 20]. S = De keys Schuiven niet naar links bij het verwijderen van A[1]!! Dat zou de heapstructuur totaal verprutsen. V = Je moet het gat in A[1] meteen opvullen met het laatste element. Een Verkeerde manier is, A[1] weg te halen en dan steeds het gat op te vullen met het kleinste kind. Dit geeft onderin een lelijk gat, en opvullen met het laatste element is niet per sé correct. Deze manier gaf in dit voorbeeld dezelfde uitkomst maar werd uiteraard niet goed gerekend.

4 5. Zoeken in Hashtabel: In een hashtabel (met chaining) heeft succesvol zoeken een andere analyse dan succesloos zoeken. Ga uit van een hashtabel met n keys en m lijsten, en load factor α = n/m. (a) Bij welk van deze twee gevallen druk je de zoektijd uit in de gemiddelde lijstlengte? Geef een uitdrukking voor de zoektijd. (b) Bij welk van de twee gevallen hangt de zoektijd af van het gemiddelde kwadraat van de lijstlengte? Leg uit waarom. Oplossing: (a) Bij de succesloze zoekactie. Je moet daar een van de lijsten, een willekeurige, doorlopen (om te constateren dat je key niet voorkomt). De tijd is O(1 + α). (b) Bij de succesvolle zoekactie wordt elke voorkomende key met gelijke kans gevraagd. Je zoekt dus in een lijst van gemiddelde lengte, waarbij je echter niet direct middelt over de lijsten, maar over de keys. Dat betekent dat bij een lijst met l elementen, deze lengte l ook l keer meeweegt in het gemiddelde. Het relevante gemiddelde is dus 1 m i (l2 i ). Beoordeling/Toelichting: Ruwweg een punt per deelvraag, maar in combinatie beoordeeld. Beoordelingscodes: A = Je hebt Alleen de match goed (van de twee gemiddelden op de twee gevallen). Verder geen zinvolle en correcte uitleg: 1/2pt. α = De 1 hoort er echt bij in O(1 + α). Je kunt de zoektijd niet willekeurig klein maken door α te verlagen, omdat de hash ook berekend moet worden. De uitdrukking O(α) voor de succesloze zoektijd is daarom strikt genomen niet juist. Omdat zeer kleine waarden van α meestal vermeden worden, is O(α) toch als F meegerekend. D = Succesvol Duurt langer is niet persé juist, omdat je (gemiddeld) halverwege de lijst stopt. F = De match is goed en de Formule voor de tijd bij (a): 1pt. G = Geen Goeie match gemaakt: 0pt. L = Bij succesloos Loop je alle lijsten af : Gelukkig niet zeg! T = ZoekTijd O(n) of O(n + m): zo traag is een hashtabel gelukkig niet! U = Uitleg te vaag, incompleet, onjuist of ontbrekend.

5 6. Meer dan x: Geef een methode Tree meerdan(tree t, key x) die, voor key x en binaire zoekboom t, de kleinste waarde y in t zoekt die strikt groter dan x is. Lever een pointer naar de knoop waar y zit, of null als er geen key > x is. Oplossing: Dit kan recursief (en zonder parent-pointers). Recursie is niet alleen een programmeertechniek, maar ook een denkwijze. Zie de boom niet als een wirwar van knopen met pijlen ertussen, maar als (1) een lege boom null of (2) een knoop met daarin een key t.key met een deelboom met kleinere keys en een deelboom met grotere keys. Een lege boom heeft geen key dus levert null. Als t.key kleinergelijk x is, zal de meerdan van x uit de rdb moeten komen. Als t.key groter dan x is, kan t het antwoord zijn, maar alleen als de ldb geen betere kandidaat levert: Tree meerdan(tree t, key x): { if (t == null) return t; if (x >= t.key) return meerdan(t.right, x); Tree ml = meerdan(t.left, x); if (ml == null) return t; else return ml; } Beoordeling/Toelichting: Voor een goede oplossing 2pt. Beoordelingscodes: C = Crasht op lege boom. Bedenk dat de invoerboom als geheel leeg kan zijn, en dat je met recursieve aanroepen meestal uiteindelijk in een lege boom uitkomt. D = Vermijd Dubbel berekenen door de laatste twee regels te vervangen door if (meerdan(t.left, x) == null) return t; else return meerdan(t.left, x); Je bedoelt t waarschijnlijk goed, maar als er een pad naar links van lengte h is, en x is kleiner dan alle keys, kost dit geintje Ω(2 h ) tijd! E = Enumeratie van alle keys, lineaire oplossing. 0pt. F = Het gaat Fout als je zondermeer naar de ldb gaat als x < t.key. Misschien heeft de ldb geen keys > x, en in dat geval moet je t opleveren. H = Een lineaire opossing kan niet Hoger dan 1pt scoren. I = Een Iteratieve oplossing kan maar is vrij lastig! Het kan zijn dat je op een zeker punt naar links gaat (omdat x < t.key) maar in die deelboom geen grotere key dan x vindt. Dan moet je terugvallen op t. Je zult dan parent-pointers moeten gebruiken (zie P) of je moet tijdens je tocht omlaag de goeie key onthouden (zie T). L = if (t.key > x) return t; is onjuist, de ldb kan een betere waarde hebben. M = Minimum uit de rdb van de knoop met x; incompleet want (1) x hoeft niet eens voor te komen en (2) die rdb kan leeg zijn en dan moet je een knoop boven x hebben. N = Behandelen van null als een mogelijke boom in je methode (dus branchen op (t == null) aan het begin) is veel beter dan lege deelbomen op diverse plekken als speciaal geval afhandelen. Het laatste kost 1/2pt. Als je het goed aanpakt, crast je programma alleen op een geheel lege input, en niet op lege deelbomen (dus bladen in je boom). P = Iteratieve oplossing met Parent pointers: zoek naar x, en vanaf x of een blad, volg de Successor procedure van Cormen. R = Levert t op als x < t.key en t.left.key < x. Onjuiste waarde, want t.left kan nog een rechterdeelboom hebben waarin keys voorkomen die nog dichter op x zitten. T = Daal af in de boom tot je x ziet of een blad, onthoud onderweg de kleinste overtreffer die je Tegenkwam.

6 7. Recurrente betrekking: Los op: a 0 = 1, a 1 = 2, a n = 4a n 1 3a n 2. Oplossing: Stel het karakteristieke polynoom op: x 2 4x + 3. Nulpunten vind je met de ABC formule: α 1 = 1 en α 2 = 3. De Algemene Oplossing is dus a n = C.1 n + D.3 n. Gebruik de gegeven waarden voor n = 0 en n = 1 en stel op: C + D = 1 en C + 3D = 2. Trek de eerste vergelijking af van de tweede en zie 2D = 1 dus D = 1/2. Met de eerste vgl geeft dit C = 1/2. Oplossing a n = 1 2 (1 + 3n ). (Controleer met de eerste waarden: 1, 2, 5, 14, 41. Klopt!) Beoordeling/Toelichting: Voor een goede oplossing 2pt. Codes: A = Kom je t/m de Algemene Oplossing a n = C.1 n + D.3 n, 1pt. C = Controleer je uitkomst! Het kost je maar 10 seconden om met de gegevens de eerste vijf waarden van a te berekenen: 1, 2, 5, 14, 41. Vul dan 2 t/m 4 in in je oplossing en zie dat 1 ( ), 1( ) en 1( ) respectievelijk 2, 14 en 41 zijn. Geen zichzelfrespecterende wiskundige zou dit als een bewijs voor de juistheid van de formule accepteren. Maar als je graag een correcte formule inlevert, is dit een handig truukje om 99% van de foute antwoorden te ontmaskeren. K = Vind je de Karakteristieke Wortels 1 en 3, maar geen AO, 0pt. M = Een Minteken in de AO, ja, dat kan natuurlijk ook. Na het vinden van 1 en 3 als KW schrijf je dan: a n = C.1 n D.3 n. Je kunt nu jouw C en D correct oplossen en je vindt dan natuurlijk C = 1 en D = 1. Helaas verdubbelt elk minteken de kans op fouten! Een 2 2 aantal kandidaten vonden deze vorm van de AO, maar het oplossen van de coëfficienten werd meestal door rekenfouten verprutst.