Datastructuren Sorteren, zoeken en tijdsanalyse

1. DatastructurenSorteren, zoeken en tijdsanalyse College 2

2. Vandaag • Medelingen over werkcollege • O-notatie • Binary search • Sorteren: analyse van insertion sort • Bubble sort • Merge Sort • Heapsort

3. Werkcollege • Groepen: • We werken met vier (en dus geen 5) groepen • We gebruiken de zalen van groepen 2, 3, 4 en 5 • Kies een zaal/groep (afhankelijk van drukte), en probeer steeds naar dezelfde groep te gaan • We beginnen zometeen • Opgaven staan online maar worden ook tijdens het werkcollege uitgereikt

4. Waarom O-notatie • Hoeveel operaties is nu eigenlijk een test als • if(A[i+1] > x) OR (x == 0) • ? • In elk geval: een constant aantal. Om dit niet precies te hoeven bekijken is de O-notatie bedacht: verstopt constanten in de notatie • 8, 9, 20203, 1: allemaal O(1) • n, 4n, 10n + log(n), 21n: allemaal O(n) Datastructuren

5. “Asympthotic notation” • O: asympthotische bovengrens • Formeel: • O(g(n)) = { f(n) | er zijn positieve constanten c en r, zodat 0 £ f(n) £ c * g(n) voor alle n ³ r} • O(g(n)) is dus een verzameling functies. In plaats van de schrijven f(n) Î O(g(n)) schrijft men echter f(n)=O(g(n)) • Intuitie: we schrijven f(n) = O(g(n)) als vanaf een bepaalde waarde van n (soms 0, soms meer) f(n) nooit meer dan een vaste constante keer g(n) is. • Dus: 3n2 = O(n2) • Nog meer voorbeelden (zometeen) • Feitelijk: laat de constante factor weg, en laat langzamer groeiende functies weg Datastructuren

6. Voorbeelden n2 + 4n + 6 log n3 12n + log n + 3 r2 – 10 23n+4 Datastructuren

8. Zoeken in een gesorteerde rij • Array met elementen A[1], …, A[n] • Gegeven een x, is er een i met A[i] == x, en zo ja, welke i? • We zagen al een algoritme dat dit oplost in O(n) tijd: bekijk de elementen van 1 t/m n totdat je x tegenkomt of alles bekeken hebt • Als de rij getallen gesorteerd is kan het sneller met een simpel maar belangrijk principe: binary search • Dus: neem aan: A[1] £ A[2] £ A[3] £ … £ A[n-1] £ A[n]

9. Binary search • Idee: houdt twee variabelen bij onder en boven, zodat x, als x in A zit, “tussen” onder en boven zit • Invariant: als er een i is met A[i] == x, dan onder£i£boven

10. Tijd van binary search • Iedere keer wordt het stuk waar je kijkt ongeveer half zo lang • Je kan log n (grondtal 2) keer doormidden delen en dan heb je een stuk van lengte 1 • Dus O(log n) stappen • Nette wiskundige analyse komt later

11. Pseudocode • {Input: Gesorteerde array A[1 … n] , element x} • {Output: index i met A[i] == x, and 0 als zo’n i niet bestaat} • onder = 1; boven = n; • while (onder < boven) do • mid = ë (onder+boven)/2 û ; • if (A[mid] < x) then onder = mid+1 else boven = mid • if (A[onder] == x) then return onder else return 0 (zit er niet in)

12. Sorteeralgoritmen • Aantal algoritmen om te sorteren • Staart vorige keer: insertion sort • Simpel algoritme: bubble sort • Sneller: merge sort (ritsen) • Ook snel: heapsort (met datastructuur: heap) • In de praktijk heel snel: quicksort

13. Insertion sort • Sorteeralgoritme, met volgende idee: • Voeg steeds één element toe op de goede plek • We hebben een steeds groter goedgesorteerd deel • Array A loopt van 1 t/m lengte(A) INSERTION-SORT(A) for j = 2 to lengte(A) do key = A[j] {voeg A[j] op de goede plek in} i = j – 1; whilei > 0 and A[i] > keydo A[i+1] = A[i] {schuif eentje op} i = i – 1; A[i+1] = key Datastructuren

14. Tijdsanalyse van INSERTION-SORT 1 • Eerst dit: • Hoeveel stappen kost één slag van de loop voor 1 bepaalde waarde van j ? • Weer een loop. • Elke doorgang door de loop kost iets van 8 elementaire stappen • Deze loop gaan we hooguit j keer rond • Nog eens 6 operaties buiten de loop • Dus 8 j + 6 operaties voor deze slag INSERTION-SORT(A) for j = 2 to lengte(A) do (*) key = A[j] {voeg A[j] op de goede plek in} i = j – 1; whilei > 0 and A[i] > keydo A[i+1] = A[i] {schuif eentje op} i = i – 1; A[i+1] = key (**) Datastructuren

15. Tijdsanalyse van INSERTION-SORT 2 INSERTION-SORT(A) for j = 2 to lengte(A) do (*) key = A[j] {voeg A[j] op de goede plek in} i = j – 1; whilei > 0 and A[i] > keydo A[i+1] = A[i] {schuif eentje op} i = i – 1; A[i+1] = key (**) • Hoeveel stappen kost één slag van de loop voor een bepaalde waarde van j ? • 8 j + 6 of minder • We doen dit voor j=2, 3, … , tot lengte(A)=n • Totaal: constante keer n2 • Schrijven we als O(n2) Datastructuren

16. Voordelen Eenvoudig Geen extra geheugen Snel als rij al gesorteerd Nadelen Langzaam: O(n2) Voor en nadelen insertion-sort

17. Eenvoudig sorteeralgoritme repeat change = false; for i=1 to n-1do if (a[i] > a[i+1]) then verwissel a[i] en a[i+1] van plaats change = true until (change == false) Bubblesort Verwissel: hulp = a[i]; a[i] = a[i+1]; a[i+1] = hulp; Hoe snel? Correct?

18. Correctheid en tijd bubble sort • Als we klaar zijn is de array gesorteerd; we hebben steeds een permutatie van de input • Terminatie? Ja, want • Na i keer de hoofdloop gedaan te hebben staan op posities n - i +1, n – i +2, … , n de i grootste getallen in de array • Dus: na hooguit n keer de hoofdloop te doen, is het array gesorteerd en zijn we klaar

19. Verwissel: O(1) Binnenste deel: O(1) For: n keer O(1): O(n) Totaal: n keer O(n): O(n2) Er zijn ook inputs waar zo’n n2stappen gedaan worden, bijv.: het omgekeerde van een gesorteerde array (10, 9, 8, 7, 6, 5, 4, 3, 2, 1) Tijd • repeat • change = false; • for i=1 to n-1do • if (a[i] > a[i+1]) • then • verwissel a[i] en a[i+1] van plaats • change = true • until (change == false)

20. Mergesort

21. Mergesort • Algoritmische methode: divide and conquer (verdeel en heers) • Splits probleem in deelstukken • Los elk deelstuk afzonderlijk op • Combineer oplossing van deelstukken • Mergesort gebruikt divide and conquer strategie • Sorteer eerst, recursief de 1e helft van de array • Sorteer daarna, recursief, de 2e helft van de array • Voeg de twee gesorteerde helften samen door een soort van ‘ritsen’

22. Merge-sort I Mergesort(A, p, r) • {Input: array A, integers p, r, met 1£p£r£ lengte(A)} • {Output: A[p..r] is gesorteerd en bevat dezelfde elementen als A[p..r] in input} • If (p ³ r) then doe niets • else • midden = ë (p+r)/2 û ; • Mergesort(A,p, midden); • Mergesort(A,midden+1,r); • Merge(A,p,midden,r); {“Rits” de twee stukken in elkaar”}

23. Merge(A,p,q,r) (deel 1) • {Input: A[p…q] is gesorteerd, en A[q+1…r] is gesorteerd} • {Output: A[p…r] is gesorteerd} • n1 = q – p +1; • n2 = r – q; • Maak een array L[1…n1+1]; • Maak een array R[1..n2+1]; • for i=1 to n1 do L[i] = A[p+i – 1]; • for j=1 to n2 do R[j] = A[q+j]; • (rest komt zometeen) Eentje extra voor stootblokken Eerst copieren in arrays L en R

24. Merge deel 2 • n1 = q – p +1; • n2 = r – q; • Maak een array L[1…n1+1]; • Maak een array R[1..n2+1]; • for i=1 to n1 do L[i] = A[p+i – 1]; • for j=1 to n2 do R[j] = A[q+j]; • L[n1+1] = MAXINT; {Stootblok (sentinel)} • R[n2+1] = MAXINT; {Stootblok}

25. Merge deel 2 • n1 = q – p +1; n2 = r – q; • Maak arrays L[1…n1+1] en R[1..n2+1]; • for i=1 to n1 do L[i] = A[p+i – 1]; • for j=1 to n2 do R[j] = A[q+j]; • L[n1+1] = MAXINT; {Stootblok} • R[n2+1] = MAXINT; {Stootblok} • pleklinks = 1; • plekrechts = 1; • for k = p to r do • {Vind het element op positie k in A} • if (L(pleklinks) £ R(plekrechts)) • then A[k] = L(pleklinks); pleklinks ++; • else A[k] = R[plekrechts); plekrechts ++;

26. Correctheid merge • Invariant • Aan het begin van de for-loop gelden: • A[p…k-1] bevat de k-p kleinste elementen uit L[1..n1+1] en R[1..n2+1] • A[p…k-1] is gesorteerd • L[pleklinks] is het kleinste element in L dat niet teruggezet is naar A • r[plekrechts] is het kleinste element in R dat niet teruggezet is naar A • Invariant geldt initieel, en blijft gelden • Bij terminatie: k = r+1; en dus ... 

27. Tijd van mergesort • Wat is de tijd van een enkele mergeoperatie? • Als we twee stukken van lengte r mergen: O(r) (want…) • Analyse van mergesort hier wat informeler – kijk naar de “berekeningsboom”

28. log n niveau’s

29. Tijd van mergesort • O(n log n)

30. ADT versus Datastructuur • Datastructuur • is een systematische manier van organiseren van data en toegang verlenen tot diezelfde data. • Abstract data type • is een model van een datastructuur waarin gespecificeerd is: • type van de data • operaties ter ondersteuning van de datastructuur • de types van de parameters van deze operaties • Een abstract data type concentreert zich op functionaliteit, niet op tijd. • Vandaag: Heap (is ADT), Array-implementatie van Heap Datastructuren

31. Heap • “Hoop”, zoals in “een steenhoop” • 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

32. Heap • “Bijna volledige binaire boom” • Vervult de “heap-eigenschap” • Wat bedoelen we hiermee?

33. Binaire boom: Iedere knoop heeft 0, 1 of 2 kinderen Volledige binaire boom: Behalve op het onderste niveau heeft elke knoop 2 kinderen Een knoop kan hebben: Ouder (PARENT) Linkerkind (LEFT) Rechterkind (RIGHT) Binaire boom

34. Alle niveau’s helemaal gevuld, behalve ‘t onderste dat een eindje van links af gevuld is, en daarna niet meer Volledige bb mag ook Bijna volledige binaire boom

35. Twee termen • Diepte van knoop: afstand naar wortel • Hoogte van knoop x: maximale afstand naar blad onder x

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

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

38. Heapsort • Gebruikt de Heap datastructuur met implementatie in array • Heap

39. 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

40. Gebruik een array A[1] is de wortel A[2], A[3] de achteenvolgende elementen op hoogte 1 A[4], A[5], A[6], A[7] voor hoogte 2, A[2r], … A[2r+1-1] voor hoogte r PARENT(i) Return ëi/2 û ; LEFT(i) Return 2i; RIGHT(i) Return 2i+1; Implementatie van een heap

41. 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

42. “Operaties” op Max-Heap • Build-Max-Heap • Maak een heap van een ongeordende array elementen • 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) • NB: Notatie boek is wat slordig (verwart ADT en implementatie, maar ik volg ‘m toch)

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

44. Als we deze operaties geimplementeerd hebben, kunnen we sorteren • Build-Max-Heap(A) • For i=0 to n-1do • B[n-i] = Heap-Extract-Max(A)

45. 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}

46. 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

47. 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

48. Max-heapify Max-Heapify(A,i) • links = LEFT(i) • rechts = RIGHT(i) • if (links £ heap-size[A] and A[links] > A[i]) • then grootste = links • else grootste = i • if (rechts £ heap-size[A] and A[rechts] > A[grootste]) • then grootste = rechts • if (grootste ¹i) • then • Verwissel A[i] en A[grootste] • Max-Heapify(A,grootste)

49. Analyse Max-Heapify • Correct? • Looptijd: O(diepte van i) • De diepte van een knoop is nooit meer dan log n, als heap-size(A)=n • Dus: O(log n)

50. 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}