1 Datastructuren Analyse van algorithmen (vervolg) Heapsort College 4.

Presentatie over: "1 Datastructuren Analyse van algorithmen (vervolg) Heapsort College 4."— Transcript van de presentatie:

1 1 Datastructuren Analyse van algorithmen (vervolg) Heapsort College 4

2 2 Vandaag  Eerst:  Meer over O-notatie en varianten daarvan  Analyse van algoritmen: kijken naar de controlestructuur  Kort: ADT vs Datastructuur  Heaps en Heapsort

3 3 ANALYSE VAN ALGORITMEN 1 Datastructuren

4 4 O-notatie en zo  O-notatie (herhaling):  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))  Allemaal waar:  3n 2 = O(n 2 )  (7 n lg n 3 ) = O(n lg n)  (2n 3 +4n 2 +3n + 5) = O(n 3 )  Maar ook zijn waar:  n lg n = O(n 2 )  n 3 = O(n 4 )  Want “O” geeft een bovengrens

5 5 Voorbeeld 1 r = 0; for i = 1 to n do for j = 1 to sqrt(n) do r = r+A[i,j] enddo Enddo Return r Datastructuren

6 6 Voorbeeld 2 z = 0; for i = 1 to n do for j = 1 to n * n do k = 1 while k < n * n do z = z + i * j * k k = k*2 z ++; z = z + 3; return z

7 7 -notatie (Omega)  -notatie:  (g(n)) = { f(n) | er zijn positieve constanten c en r, zodat f(n)  c * g(n) voor alle n  r}  (g(n)) is dus weer een verzameling functies. In plaats van de schrijven f(n)   (g(n)) schrijft men echter f(n)= (g(n))  Deze notatie geeft ondergrenzen, terwijl de O- notatie bovengrenzen gaf  Vb.: het bubblesort-algoritme gebruikt in het slechtste geval n 2 ) tijd  Vb.: het mergesort-algoritme gebruikt in het slechtste geval (n lg n) tijd

8 8 Voorbeelden  Allemaal waar:  3n 2 =  (n 2 )  (7 n lg n 3 ) =  (n lg n)  (2n 3 +4n 2 +3n + 5) =  (n 3 )  Maar ook zijn waar:  n lg n =  (n)  n 3 =  (n 2 )  Want “” geeft een ondergrens

9 9 -notatie (Theta)  -notatie combineert O-notatie en -notatie  f(n) = (g(n)), dan en slechts dan als f(n) = O(g(n)) en f(n) = (g(n))  Dus:  3n 2 = (n 2 )  Maar niet: 3n 2 = (n 3 ) en niet: 3n 3 = (n 2 )

10 10 Wanneer gebruik je welke notatie  (f(n)): ondergrenzen  O(f(n)): bovengrenzen  (n 2 ): exacte grenzen In de literatuur gebruikt men soms de O- notatie terwijl men  weet Datastructuren

11 11 Verschillende tijdgrenzen  Slechtste geval (worst case)  Wordt het meest bekeken  Beste geval  Niet het meest interessant…  Gemiddelde geval  Gemiddelde over alle mogelijke inputs  Vaak moeilijk uit te rekenen  Heeft elke input in de praktijk evenveel kans  Verwachte tijd  Bijv. als we een gerandomiseerd algoritme nemen Datastructuren

12 12 Voorbeelden van tijdgrenzen tot nu toe (1)  Zoeken van element in een array:  Ongesorteerd array, linear search: (n) slechtste geval, (n) gemiddeld, (1) beste geval  Gesorteerd array, binary search: (log n) slechtste geval, (log n) gemiddeld, (log n) beste geval ( beste geval hangt af van implementatie ) Datastructuren

13 13 Voorbeelden van tijdgrenzen tot nu toe (2)  Bubble sort, insertion sort: (n 2 ) slechtste geval, (n 2 ) gemiddeld (niet behandeld) (n) beste geval  Merge sort: tijd hangt niet echt van input af: (n log n) slechtste geval, (n log n) gemiddeld, (n log n) beste geval  Quicksort: (n 2 ) slechtste geval, (n log n) gemiddeld (en randomized: verwacht) (n log n) beste geval Datastructuren

14 14 HEAPS EN HEAPSORT EN EERST WAT HERHALING 2 Datastructuren

15 15 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 Wat en hoe?

16 16 Voorbeeldje  ADT: SearchSet  Operatie: IsElement(x): geeft Boolse waarde die vertelt of x in een bepaalde verzameling zit  Datastructuur 1. Ongesorteerde array: operatie kost O(n) tijd 2. Gesorteerde array: operatie kost O(log n) tijd 3. Heap, gebalanceerde boom, hashtabel …

17 17 Heap vs ADT  Concepten van ADT en Datastructuur zitten bij Heap een beetje doorelkaar  Latere ADT’s en datastructuren zijn ‘zuiverder’  Bijvoorbeeld: we hebben een operatie, die een bepaalde implementatie van een heap snel omvormt tot een geordende array

18 18 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

19 19 Wat is een heap?  Je hebt max-heaps en min-heaps  Een max-heap is een  Bijna volledige binaire boom, die de  Max-heap eigenschap vervult ... Maar wat bedoelen we hiermee??  O, ja, en een min-heap is... Datastructuren

20 20 Binaire boom  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)

21 21 Bijna volledige binaire boom  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)

22 22 Termen  Wortel  Diepte van knoop: afstand naar wortel  Hoogte van knoop x: maximale afstand naar blad onder x Zwarte knoop: Diepte 1 Hoogte 2 Zwarte knoop: Diepte 1 Hoogte 2

23 23 Twee soorten heaps  Max-heap: heeft de max-heap eigenschap  Min-heap: heeft de min-heap eigenschap  Werken eigenlijk net hetzelfde met omgewisseld

24 24 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]

25 25 16 14 8 241 7 10 93 Max-heap

26 26 2 7 18 224211 9 10 1913 Min-heap

27 27 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)

28 28 Implementatie van een heap 16 14 8 241 7 10 93 1 2 3 4 5 6 7 8 9 1614108793241

29 29 Implementatie van een heap  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[2 r ], … A[2 r+1 -1] voor hoogte r  Vb komt hierna PARENT(i)  return  i/2  LEFT(i)  return 2i; RIGHT(i)  return 2i+1;

30 30 Array implementatie PARENT(i)  return  i/2  LEFT(i)  return 2i; RIGHT(i)  return 2i+1; 16 14 8 241 7 10 93 1 2 3 4 5 6 7 8 9 1614108793241

31 31 Wat telwerk (1)  Er zijn 2 i knopen met diepte i als laag i vol is  1 knoop op diepte 0, 2 op diepte 1, en steeds twee keer zoveel op een laag als op de vorige  Er zijn 2 i -1 knopen met diepte kleiner dan i  Dus: de knopen met diepte i hebben rangnummer 2 i tot en met 2 i+1 -1 Datastructuren Ik praat alleen over volle lagen

32 32 Telwerk 2  Omdat elke knoop op diepte i twee kinderen op diepte i+1 heeft heeft de jde knoop op diepte i als kinderen de 2j-1 e knoop op diepte i+1 en de 2j e  De jde knoop op diepte i heeft nummer 2 i + j – 1  De 2j-1 e knoop op diepte i+1 heeft nummer 2 i+1 + 2j – 2  De 2j e knoop op diepte i+1 heeft nummer 2 i+1 + 2j – 1 Datastructuren

33 33 Dus: het klopt! PARENT(i)  return  i/2  LEFT(i)  return 2i; RIGHT(i)  return 2i+1; 16 14 8 241 7 10 93 1 2 3 4 5 6 7 8 9 1614108793241

34 34 “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)

35 35 Build-Max-Heap  Maakt van een ongesorteerde array elementen een heap: Datastructuren 16 14 8 241 7 10 93 1 2 3 4 5 6 7 8 9 1614108793241 1411027164839

36 36 Max-heap-insert  Voegt een element toe aan een max-heap Datastructuren 16 14 8 241 7 10 93 2 3 4 5 6 7 8 9 16 8 2 4 1 7 10 93 2 3 4 5 6 7 8 9 14

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

38 38 Heap-increase-key  Verhoog de waarde van een key en zorg dat je na afloop weer een max-heap hebt Datastructuren 16 14 8 241 7 10 93 2 4 5 6 8 9 16 15 8 241 14 10 93 2 4 5 6 8 9

39 39 Heap-max  Geef het grootste element uit de max-heap  Verandert verder niets 16 14 8 241 7 10 93 2 4 5 6 8 9 Output: 16

40 40 Min-heaps  Net als Max-heaps met min en max (etc.) omgedraaid

41 41 Als we deze operaties geimplementeerd hebben, kunnen we sorteren Sorteren-Met-Heap- 1eVersie(A)  Build-Max-Heap(A)  Maak array B[1…n]  for i=0 to n-1 do  B[n-i] = Heap-Extract- Max(A)  Algoritme hiernaast sorteert; gebruikt extra array B  Maar ‘t kan ook zonder extra array (komt straks)

42 42 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}

43 43 16 4 8 251 7 10 93 1 2 3 4 5 6 7 8 9 Idee: als i groter (  ) is dan beide kinderen: OK, klaar Anders, verwissel met grootste kind en ga dan corrigeren op de plek van ‘t grootste kind

44 44 16 4 251 7 10 93 1 2 3 4 5 6 7 8 16 4 251 7 10 93 1 2 3 4 5 6 7 8 8 8

45 45 16 4 251 7 10 93 1 2 3 4 5 6 7 8 8 16 42 5 1 7 10 93 1 2 3 4 5 6 7 8 8

46 46 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) Reken uit wie de grootste is: A[i],A[links] of A[rechts]

47 47 Analyse Max-Heapify  Correct? Jazeker!  Looptijd: O(hoogte van i)  Met wat hulplemma’s  O(lg n)

48 48 Hulplemma’s  Een volledige binaire boom met hoogte r heeft 2 r+1 -1 knopen  Bewijs: waar als r=0. Als r>0, wortel plus twee deelbomen van diepte r-1 en 1+(2 r -1)+(2 r -1)= 2 r+1 -1.  Een bijna volledige binaire boom met hoogte r heeft maximaal 2 r+1 -1 knopen  Een heap met n elementen heeft hoogte maximaal  lg n .

49 49 Tijd Max-Heapify  O(hoogte van i) = O(lg n)

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

51 51 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);  for i=  lengte(A)/2 downto 1 do  Max-Heapify(A,i) That’s all en ‘t klopt ook nog! That’s all en ‘t klopt ook nog!

52 52 Correctheid Build-Max-Heap  Invariant: aan het begin van de for-loop is elke knoop i+1, … n de wortel van een max-heap  Initieel: klopt, want boompjes van 1 knoop  Onderweg: vanwege Max- Heapify… (bespreken details)  Bij terminatie: fijn, want i=0, dus knoop 1 is wortel van max-heap, dus hele array is max-heap for i=  lengte(A)/2  downto 1 do Max-Heapify(A,i)

53 53 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 h+1 knopen met hoogte h in de boom  Gebruik dat

54 54 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 h+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)

55 55

56 56 Heapsort Heapsort(A)  Build-Max-Heap(A)  for i = 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 zonder extra geheugen in O(n lg n) tijd

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

58 58 Analyse  Correct, want …  O(n lg n) tijd want…

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

60 60 Heap-Extract-Max(A)  if heap-size(A)<1 then error  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

61 61 Heap-Increase Key Heap-Increase-Key(A,i,key)  if key < A[i] then error  else  A[i] = key  while i>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)

62 62 16 152 5 1 7 10 93 8 16 15 251 7 10 93 8 16 15 251 7 10 93 8

63 63 Heap-Insert 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

64 64 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

65 65 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

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