Datastructuren Heapsort

1. DatastructurenHeapsort College 4-I

2. Heap • “Hoop”, zoals in “een steenhoop” • ADT/Datastructuur, gebruikt voor sorteren en priority queue • Een heap is eigenlijk een boom, maar kan heel efficient in een array worden weergegeven • Datastructuren voor “echte” bomen komen later

3. Bijna volledige binaire boom: Alle niveau’s helemaal gevuld, behalve ‘t onderste dat een eindje van links af gevuld is, en daarna niet meer Volledige binaire bomen mogen ook (speciaal geval) Bijna volledige binaire boom

4. Heaps • Elke knoop x in de heap heeft een waarde A[x] • Max-heap: • Bijna volledige binaire boom met de • Max-heap eigenschap: voor alle knopen i (behalve natuurlijk de wortel van de boom) geldt: A[PARENT(i)] ³ A[i] • Min-heap: • Bijna volledige binaire boom met de • Min-heap eigenschap: voor alle knopen i (behalve natuurlijk de wortel van de boom) geldt: A[PARENT(i)] £ A[i]

5. 16 10 14 9 3 8 7 2 4 1 Max-heap

6. 2 10 7 19 13 18 9 22 42 11 Min-heap

7. Heapsort • Gebruikt de Heap datastructuur met implementatie in array • Heap kan heel goed worden geimplementeerd met een “gewoon” array • We hebben een variable heapsize: geeft aan hoeveel elementen in ‘t array tot de heap behoren (1 t/m heapsize zijn heap-elementen) • Bij sorteren worden de elementen NA heapsize gebruikt om gesorteerde deel op te slaan (komt)

8. Implementatie van een heap 1 16 3 2 10 14 7 5 9 3 4 8 7 6 2 4 1 8 10 9 16 14 10 8 7 9 3 2 4 1

9. PARENT(i) returnëi/2 û ; LEFT(i) return 2i; RIGHT(i) return 2i+1; Array implementatie 1 16 3 2 10 14 5 9 3 4 8 7 6 7 2 4 1 8 10 9 16 14 10 8 7 9 3 2 4 1

10. “Operaties” op Max-Heap • Build-Max-Heap • Maak een heap van een ongeordende array elementen • Gebruikt subroutine: Max-Heapify • Max-Heap-Insert • Voeg een nieuw element toe aan een heap • Heap-Extract-Max • Haal het grootste element uit de heap en lever dat op • Heap-Increase-Key • Verhoog de waarde van een element • Heap-Maximum • Lever de waarde van het grootste element op (zonder iets te veranderen)

11. Build-Max-Heap • Maakt van een ongesorteerde array elementen een heap: 14 1 10 2 7 16 4 8 3 9 16 1 3 2 10 14 5 9 3 4 8 7 6 7 2 4 1 8 10 16 14 10 8 7 9 3 2 4 1 9 Datastructuren

12. Max-heap-insert • Voegt een element toe aan een max-heap 14 16 16 3 2 3 10 2 14 10 8 5 9 3 4 5 8 7 9 3 6 4 4 7 6 7 7 2 4 1 8 1 2 8 10 10 9 9 Datastructuren

13. Heap-extract-max • Haalt het grootste element uit een max-heap en lever dat op • Zorg dat je weer een heap hebt na afloop 14 16 2 10 8 2 10 14 5 9 3 4 4 7 6 5 9 3 4 8 7 6 1 Output: 16 2 8 2 4 1 10 8 10 9 9

14. Heap-increase-key • Verhoog de waarde van een key en zorg dat je na afloop weer een max-heap hebt 16 16 2 10 15 2 10 14 5 9 3 4 8 14 6 5 9 3 4 8 7 6 2 4 1 8 10 2 4 1 8 9 10 9 Datastructuren

15. Heap-max • Geef het grootste element uit de max-heap • Verandert verder niets 16 Output: 16 2 10 14 5 9 3 4 8 7 6 2 4 1 8 10 9

16. Min-heaps • Net als Max-heaps met min en max (etc.) omgedraaid

17. Belangrijke subroutine: Max-Heapify Max-heapify(A,i) • {Input-aanname: de binaire boom met wortel LEFT(i) en de binaire boom met wortel RIGHT(i) zijn max-heaps} • {Output: permutatie, zodat de binaire boom met wortel i is een max-heap}

18. 1 16 3 2 10 4 5 9 3 4 8 7 6 7 2 5 1 8 10 9 Idee: als i groter (³) is dan beidekinderen: OK, klaarAnders, verwissel met grootste kinden ga dan corrigeren op de plek van ‘tgrootste kind

19. 1 16 3 2 10 4 5 9 3 4 8 7 6 7 1 2 5 1 8 16 10 3 2 10 8 5 9 3 4 4 7 6 7 2 5 1 8 10

20. 1 16 3 2 10 8 5 9 3 4 4 7 6 7 2 5 1 8 10 1 16 3 2 10 8 5 9 3 4 5 7 6 7 2 4 1 8 10

21. Max-heapify Max-Heapify(A,i) • links = LEFT(i) • rechts = RIGHT(i) • if (links£ heap-size[A] and A[links] > A[i]) • thengrootste = links • elsegrootste = i • if (rechts£ heap-size[A] and A[rechts] > A[grootste]) • thengrootste = rechts • if (grootste¹i) • then • Verwissel A[i] en A[grootste] • Max-Heapify(A,grootste) Reken uitwie degrootste is: A[i],A[links]of A[rechts]

22. Analyse Max-Heapify • Correct • Tijd O(hoogte van knoop) = O(log n)

23. Build-Max-Heap Build-Max-Heap(A) • {Input: ongesorteerde rij getallen A[1…lengte(A)]} • {Output: A is een permutatie van input die aan max-heap eigenschap voldoet}

24. Build-Max-Heap Build-Max-Heap(A) • {Input: ongesorteerde rij getallen A[1…lengte(A)]} • {Output: A is een permutatie van input die aan max-heap eigenschap voldoet} • heap-size[A] = lengte(A); • fori= ë lengte(A)/2 û downto 1 do • Max-Heapify(A,i) That’s all en ‘t klopt ook nog!

25. Tijdsanalyse Build-Max-Heap • Eenvoudige analyse geeft O(n lg n) • Voor iedere i tussen 1 en n/2 doen we O(lg n) werk • Meer precieze analyse geeft O(n). Plan: • Werk voor knoop i is O(hoogte(i)+1) • De hoogte van de boom is ë lg n û (basis 2) • Er zijn én / 2h+1ù knopen met hoogte h in de boom • Gebruik dat

26. Analyse Build-max-heap • Werk voor knoop i is O(hoogte(i)+1) • De hoogte van de boom is ë lg n û • Er zijn maximaal én / 2h+1ù knopen met hoogte h in de boom • Bewijs met inductie omlaag: als h = ë lg n û dan is er 1 knoop: wortel; voor kleinere h maximaal twee keer zoveel als voor hoogte h+1 • Totale werk is …= O(n)

28. Heapsort Heapsort(A) • Build-Max-Heap(A) • fori = lengte(A) downto 2 do • {A[1] is het maximum} • {A[1…heap-size[A]} is een heap, de elementen na heap-size[A] zijn gesorteerd maar niet langer in de heap} • {Invariant: i = heapsize[A]} • Verwissel A[1] en A[i]; • Heapsize[A] --; • Max-Heapify(A,1); Sorteert zonderextra geheugenin O(n lg n) tijd

29. Array is ongesorteerde rij elementen Max-heapify Array is heap 2e deel heapsort Array is gesorteerde rij elementen

30. Analyse • Correct, want … • O(n lg n) tijd want…

31. Heap-Maximum(A) return A[1]; Geef de waarde van het grootste element uit heap A Heap-Maximum(A)

32. Heap-Extract-Max(A) if heap-size(A)<1 thenerror else max = A[1]; A[1] = A[heap-size[A]]; heap-size[A] --; Max-Heapify(A,1); return max; Geef de waarde van het grootste element uit A en haal dit element weg Vgl. met stap uit Heap-sort Heap-Extract-Max(A)

33. Heap-Increase-Key(A,i,key) ifkey < A[i] thenerror else A[i] = key whilei>1 and A[parent[i]] < A[i] do Verwissel A[i] en A[parent[i]]; i = parent[i] Verhoog de waarde van element A[i] tot key Verlaging is niet toegestaan; geven we foutmelding Als in boek. Niet zo moeilijk om code te veranderen zodat je ook keys kan verlagen (als Max-Heapify) Heap-Increase Key

34. 16 16 10 8 10 8 9 3 5 7 9 3 15 7 2 15 1 2 5 1 16 10 15 9 3 7 8 2 5 1

35. Max-Heap-Insert(A,key) heap-size[A]++; A[heap-size[A]] = - ¥ Heap-Increase-Key(A,heap-size[A],key) Zolang array A groot genoeg is werkt dit Heap-Insert

36. Priority queue • Priority queue is Abstract Data Type met volgende operaties: • Insert (S, x): voeg element x in verzameling S toe • Maximum(S): geef het grootste element uit S • Extract-Max(S): geef het grootste element uit S en haal dit uit de verzameling S weg • Increase key (S, x, k): verhoog de waarde van x tot k • Elementen hebben een waarde uit een totaal geordende verzameling (bijv. ze zijn getallen) • Toepassing bijvoorbeeld: taakselectie in multi-user systeem • Heap implementeert Priority Queue

37. Heap implementeert Priority Queue • Insert: O(lg n) mits oorspronkelijk aangemaakte array groot genoeg • Maximum: O(1) • Extract-Max: O(lg n) • Increase-Key: O(lg n) Snel

38. Hierna • Nog sneller sorteren: kan dat??? • Ja, maar alleen als er iets bijzonders aan de hand is… (gebruik makend van eigenschappen van de gegevens)