Opgaven Heaps Datastructuren, 8 juni 2018, Werkgroep.

Transcriptie

1 Opgaven Heaps Datastructuren, 8 juni 2018, Werkgroep. 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. Is het een Heap: Zie boek: Cormen, vraag Oplossing: Nee, want 7 op positie 9 is een kind van 6 op positie Zero Based Heap: Geef formules voor P(i), L(i) en R(i) die een heap implementeren in een 0-based array. Oplossing: L(i) = 2*i+1, te berekenen als: (i<<1) 1. R(i) = 2*i+2, te berekenen als (i+1)<<1. P(i) = (i-1)/2 ofwel (i-1)>>1. Dit ziet er redelijk simpel uit, maar increment en decrement zijn in feite veel moeilijker operaties dan puntsgewijze OR, AND of shift! Het is al best lastig om een circuit te bedenken dat een k-bits getal increment en diepte o(k) heeft. De functies voor one-based arrays zijn dus wel echt sneller. 3. Eigenschappen ordenen: Laat zien dat de eigenschap Array A is een MinHeap strikt sterker is dan de eigenschap Het kleinste element van A staat vooraan, maar strikt zwakker dan de eigenschap Array A is gesorteerd. Oplossing: Val terug op Logica en merk op dat: P is strikt sterker dan Q betekent dat P impliceert Q, maar Q kan waar zijn terwijl P onwaar is. Voor de implicatie zoek je meestel een bewijs (redenering), voor het tweede stuk een voorbeeld. 4. Sibling van positie in Heap: Geef een formule S(i) die de Sibling van i bepaalt, oftewel, de positie met dezelfde ouder als i. Oplossing: Voor even i is dit i + 1 en voor oneven i is dit i 1. In een klap te berekenen met de bitoperatie Xor: j = (i ^ 1). 5. Elementen in Heap: Zie boek: Cormen, vraag Oplossing: Op laag h van de heap, dus h stappen onder de root 1, vinden we locaties met indices 2 h t/m 2 h+1 1. De hoogte van de heap is h als een van deze knopen de hoogst genummerde is, dus het aantal elementen moet 2 h t/m 2 h+1 1 zijn. Check dit eentueel met de hand voor hoogtes 1 en 2.

2 6. Hoogte van Heap: Zie Boek, Cormen vraag Oplossing: Voor alle aantallen elementen waarvoor de hoogte h is, geldt 2 h n 2 h+1 1. Deze voldoen allemaal aan lg n = h. 7. Max in Subheap: Zie Boek, Cormen vraag Oplossing: Dit kun je mooi bewijzen met inductie naar de hoogte van de subtree. Als de subtree van x = A[i] hoogte 0 heeft (dwz., i > n/2), zitten er geen keys meer onder A[i], daarmee is x de enige en dus meteen grootste key in de subtree. Stel dat de hoogte h + 1 is; dan heeft x een linker-, en misschien rechterkind, beide de root van een subtree met hoogte h of h 1. Uit de IH volgt dat die kinderen de max in hun subtree zijn, de MaxHeap-eigenschap zegt dat x minstens zo groot is als die kinderen, waarmee geen enkele key in de subtree groter dan x kan zijn. 8. Sortering impliceert Minheap: Zie Boek, Cormen vraag Oplossing: Jazeker; sortering impliceert dat A[i] groter is dan A[j] voor elke j < i. Dus zeker voor j = P (i) is dat zo. 9. Minimum in Maxheap: Zie Boek, Cormen vraag Oplossing: De aanname dat de elementen verschillend zijn, maakt het minimum uniek (dwz., er is er maar een). Dit minimum mag geen kind hebben, want hij mag niet kleiner zijn dan een kind en is er volgens het gegeven ook niet gelijk aan. Op positie n/2 heb je nog wel een kind (nl. n) maar op hogere posities niet meer. De minimum key kan daarom alleen zitten op plaatsen n/2 + 1 t/m n. Om te bewijzen dat ook al deze posities mogelijk zijn: neem een aflopend gesorteerde array, en verwissel de laatste (pos. n) met een van deze posities. Over de plek waar het minimum komt maak ik me geen zorgen, want hij zal ook daar zeker kleiner zijn dan zijn ouder. Het nieuwe element moet kleiner zijn dan A[ n/2 ], maar omdat hij komt van positie n/2 +1 of hoger, is dat zeker het geval. 10. Binair geïndexeerde Heap: Teken de boomstructuur van een Heap met 14 knopen en schrijf de indices erbij in binaire notatie. Hoe luiden de P, L en R functie op de binaire notatie? Oplossing: P is: laatste bit wegknippen. L is: 0 erachter zetten. R is: 1 erachter zetten.

3 11. De heap ondersteboven: Anton implementeert zijn Heap niet aan de lage, maar aan de hoge kant van zijn array. Dwz., positie A[n-1] is de root, met kinderen A[n-2] en A[n-3], etc. Geef formules voor R(i), L(i) en P(i) om de kinderen en de ouder van positie i te berekenen. Oplossing: 12. Key Update in Heap: Geef een methode UpdateKey(i,k) voor een MinHeap, die de waarde van key A[i] verandert in k en de heap herstelt in O(lg n) tijd. Oplossing: Begin met oud=a[i]; A[i]=k; en dan, afhankelijk van op oud kleiner of groter dan k is, een Heapify(i) of een Rootify(i). 13. Zoeken in een Heap: Schrijf een methode Search(k) voor een MinHeap, die een i oplevert met A[i]==k, of 1 als k niet voorkomt. Wat is de rekentijd van je methode? Oplossing: Het kan in lineaire tijd door gewoon lineair zoeken: for (i=1; i<=n; i++) if (A[i]==k) return i; return -1; Je kunt deelbomen overslaan met bovenaan een key groter dan k, maar omdat de keys bovenin juist heel klein zijn, zul je hier weinig mee winnen. De worst case is altijd Ω(n). 14. MiniMaxHeap: Kan een array zowel MinHeap als MaxHeap tegelijk zijn? Oplossing: Ja. MinHeap impliceert dat vooraan de kleinste key staat en MaxHeap dat vooraan de grootste key staat. Die moeten dus aan elkaar gelijk zijn, oftewel, alle keys zijn aan elkaar gelijk. Een array met op de eerste n plaatsen eenzelfde waarde, is zowel Min- als MaxHeap, en dit is de enige mogelijkheid. De omstandigheid waar n = 1 is het makkelijkst te bedenken, maar zoals je ziet niet de enige.

4 15. Mergen met PrioQueue: Mario onderzoekt of je sneller kunt MergeSorten door niet steeds twee, maar a lijsten te mergen. In de Merge methode moet je dan steeds de kleinste waarde van de voorkant van een van de a lijsten pakken. Mario heeft natuurlijk goed opgelet bij Datastructuren en bedenkt, dat hij hiervoor een PriorityQueue kan gebruiken met de lijsten als elementen. (a) Schrijf code voor het Mergen van a lijsten. (b) Hoeveel tijd kost de Merge (uitgedrukt in totaal aantal elementen)? (c) Geef een Recurrente Betrekking voor Mario s a-aire Merge Sort en los die op. (d) Is het sneller dan tweeweg-mergesort? Oplossing: (a) Dit ziet er ongeveer zo uit: Zet Enumerators van lijsten in array BuildHeap; Result = Leeg; while (..) L = ExtractMin; Result.Add(L.Current); if (L.MoveNext) Insert(L) (b) De BuildHeap kost Mario Θ(a), daarna volgen n extractmins en n a Inserts, met totale kosten O(n lg a). (c) De kosten voor Mario s MergeSort laten zich uitdrukken als M(n) = a M(n/a) + Θ(n lg a). Omdat de vertakkingsgraad en de verdelingsgraad gelijk zijn, is het totaal van de instantiegroottes op elk nivo van de RecursieBoom gelijk, nl n. Het totale werk binnen een nivo is dus Θ(n lg a). Omdat de recursiediepte a log n is oftewel lg n/ lg a, is het totale werk: Θ(n lg n). (d) Als Mario nog iets beter had opgelet bij Datastructuren, had hij vast nog wel geweten dat MergeSort asymptotisch optimaal is. Zijn nieuwe algoritme is dus zeker niet beter dan het oude. 16. MinHeap met Max: Max wil een PriorityQueue die behalve Insert, Min en ExtractMin, (uiteraard!) ook een methode Max heeft die de grootste key oplevert. Een ExtractMax hoeft niet. Help Max met een O(1) Max. Oplossing: De grootste key zoeken in een MinHeap is vrij duur. Voor dit probleem is het zinvol, je af te vragen wanneer de max-waarde in de heap eigenlijk kan veranderen. Omdat er geen ExtractMax is, kan het aanwezige maximum alleen veranderen door een Insert van een waarde groter dan het maximum, of een ExtractMin waarbij de queue leeg wordt. Houd de grootste aanwezige key apart bij in variabele mx. Deze moet je updaten met een Insert en resetten wanneer de verzameling leeg wordt.

5 17. MediaanQueue: De MediaanQueue heeft een operatie Insert(k) en een ExtractMid die de middelste key (mediaan) oplevert en verwijdert. Geeft een implementatie met twee Heaps, die beide operaties in O(lg n) tijd ondersteunt. Oplossing: De MediaanQueue bestaat uit een MaxHeap die de kleinste helft van de keys bevat en een MinHeap met de grootste helft. De ExtractMid levert de ExtractMax uit de eerste helft. De Insert kijkt of de nieuwe waarde in de onderste of bovenste helft valt en begint met een Insert in die helft. Door beide operaties kan een disbalans ontstaan. Zodra een van beide Heaps twee elementen meer bevat dan de andere, doe je daar een Extract en je Insert de waarde aan de andere kant. 18. De QuickHeap: Quentin beweert over een datastructuur QuickHeap te bechikken, die Insert en ExtractMin beide in O(lg lg n) tijd ondersteunt. Bewijs dat dit onmogelijk is. Hint: Gebruik de bekende ondergrens voor sorteren. Oplossing: Dit bewijzen we met een techniek genaamd Reductie, namelijk door sorteren te reduceren tot PriorityQueue. Probleem A reduceren tot B betekent: stel dat je een werkende implementatie van B hebt, en beschrijf hoe je die kunt aanroepen om A op te lossen. Stel dat we Quentins QuickHeap hebben en n getallen willen sorteren. We kunnen dit voor elkaar krijgen door n maal de Insert te gebruiken, en dan n maal de ExtractMin. Gezien Quentins claim, zou dit n + n maal O(lg lg n) kosten. Met zijn datastructuur zou je dus een verzameling van n keys kunnen sorteren in O(n lg lg n) tijd, waarvan we weten dat dit onmogelijk is. Quentins claim is dus onwaar. Tot 2pt voor een goede redenering die Quentins claim ontkracht. De gebruikte ondergrens voor Sorteren geldt natuurlijk alleen in het comparisonmodel. 19. Twee- en Driemachten: Geef een manier om een lijst van getallen van de vorm 2 i 3 j op te leveren in gesorteerde volgorde. Oplossing: Gebruik een PriorityQueue en stop 1 erin en herhaal: s = ExtractMin; Insert(2*s); Insert(3*s); print(s); zolang als gewenst. 20. Optellen zonder afronden: Hoe kun je n Doubles bij elkaar optellen met minimale afrondfouten? Oplossing: Neem steeds de kleinste twee getallen bij elkaar; houd hiertoe de getallen bij in een PQ.

6 21. MinHeap: Deze vraag gaat over een MinHeap in een 1-based array A. In A staan deze getallen: (8, 48, 31, 20, 18, 33, 35, 30, 45, 21, 20, 35). (a) Welke veranderingen vinden plaats als Heapify(2) wordt aangeroepen? (b) Vervolgens wordt key 27 toegevoegd. Zeg wat er gebeurt en geef de heap na toevoeging. (c) Welke posities in een heap met n keys hebben geen kinderen, welke hebben 1 kind en welke hebben 2 kinderen? Oplossing: (a) De key op plaats 2, 48, wisselt met zijn kleinste kind 18 op plaats 5. Dan wordt Heapify(5) aangeroepen en wisselt 48 weer met zijn kleinste kind, 20 op positie 11. Dan wordt Heapify(11) aangeroepen maar positie 11 heeft geen kinderen en er gebeurt niets meer. Heap is dus: (8, 18, 31, 20, 20, 33, 35, 30, 45, 21, 48, 35) (b) Nieuwe keys worden toegevoegd op de eerste lege plek en dan wordt Rootify aangeroepen. Dus 27 komt op plek 13, en Rootify(13) laat hem wisselen met zijn parent op plek 6, 33, want dat getal is groter. De volgende Rootify(6) laat 27 wisselen met zijn parent 31 op plek 3 want die is groter. De volgende Rootify(3) doet niets meer omdat 27 groter is dan zijn parent 8. Heap dan: (8, 18, 27, 20, 20, 31, 35, 30, 45, 21, 48, 35, 33). (c) Kinderen van knoop i zijn 2i en 2i + 1 maar deze bestaan alleen als dat kleinergelijk n is. Elke positie i < n/2 heeft twee kinderen. Alleen als n even is, bestaat er een knoop met 1 kind en dat is n/2: linkerkind is n (bestaat) en rechterkind is n + 1 (bestaat niet). Posities groter dan n/2 hebben geen kinderen. Tot 3pt, 1 voor elke deelvraag. A = Niet Algemeen genoeg (antwoord bv alleen voor n een tweemacht), 0pt. E = Geen onderscheid Even/oneven gemaakt. T = Grens tussen 0 of 2 kinderen ligt niet bij Tweemacht. V = Bij (b) staat Vervolgens, je moet dus toevoegen na het Heapifyen uit (a).

7 22. Delete uit Heap: Geef een methode void Delete(int i), die uit een MinHeap A het element op positie i verwijdert (in logaritmische tijd; je mag Rootify en Heapify als gegeven veronderstellen). Oplossing: Begin met het laatste element op plek i te zetten. om het achterste element op de opengevallen plek te zetten. Op positie i kunnen nu twee dingen mis zijn. (1) Als het element groter is dan een van zijn kinderen moet je Heapify(i) toepassen (Bubble Down); en Heapify stopt vanzelf als deze conditie niet geldt. (2) Als het element kleiner is dan zijn ouder moet je omwisselen en met de ouder verder gaan (Bubble Up); ook Rootify stopt vanzelf als verdergaan niet nodig is. void Delete(int i) { A[i] = A[n--]; Heapify(i); Rootify(i); } Tot 2pt voor een complete methode. N = Op Null zetten of met Nullen goochelen doen we in een heap niet! Per definitie zijn de plekken 1 t/m n met keys gevuld. R = Zonder Rootify is t niet goed, want de key die op plek i komt, kan kleiner zijn dan zijn parent! T = Omdat Rootify en Heapify zelfstoppend zijn, is een test overbodig. De test of t nodig is zit er als het ware al in. V = Verlaag de counter voor de Heapify, ander stopt Heapify misschien verkeerd.

8 23. 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]. 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.