De presentatie wordt gedownload. Even geduld aub

De presentatie wordt gedownload. Even geduld aub

1 Datastructuren Quicksort College 3. 2 Vorige keren  O-notaties  Sorteren: insertion sort, bubble sort  Kosten (n 2 ) tijd in het slechtste geval.

Verwante presentaties


Presentatie over: "1 Datastructuren Quicksort College 3. 2 Vorige keren  O-notaties  Sorteren: insertion sort, bubble sort  Kosten (n 2 ) tijd in het slechtste geval."— Transcript van de presentatie:

1 1 Datastructuren Quicksort College 3

2 2 Vorige keren  O-notaties  Sorteren: insertion sort, bubble sort  Kosten (n 2 ) tijd in het slechtste geval  Sorteren: merge sort  Kosten (n lg n) tijd in het slechtste geval  Zoeken: binary search  Zoeken in een geordende array: (lg n) tijd  Quicksort: begin

3 3 Vandaag  O-notatie:  en   Quicksort: eind  Heapsort

4 4 Sorteeralgoritmen overzicht  (n 2 ): bubble sort, insertion sort  (n lg n): merge sort, heapsort (komt nog)  Geen extra geheugen: bubble sort, insertion sort, heapsort  Wel extra geheugen: merge sort

5 5 1 Orde notaties

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

7 7 Bewijzen dat algoritme O-grens haalt  Te bewijzen: algoritme gebruikt O(f(n)) tijd.  Zo doe je dat:  Toon aan dat voor alle inputs, de tijd niet meer is dan een constante maal f(n), n de inputgrootte  Verschillende methoden:  Inspectie van loop-structuur  Analyse van “recursieboom”  Andere technieken komen nog

8 8 Voorbeeld  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

9 9 -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

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

11 11 -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 )

12 12 Van snel naar langzaam  (1), (lg lg n)  (lg n), (lg 2 n), (n), (n),  (n lg n), (n lg 2 n), (n n),  (n 2 ), (n 2 lg n), (n 3 ), (n 4 ),  (2 n ), (3 n ), (n!),  (busybeaver(n)) ( bijvoorbeeld: maximum aantal stappen dat een terminerend programma met n symbolen opgeschreven kan doen )  Snel algoritme  langzaam stijgende functie (en omgekeerd)

13 13 Herhaling + Vandaag  Quicksort  Snel sorteer algoritme  Gebruikt gemiddeld weinig tijd: (n lg n) met in de praktijk een kleine constante  Maakt gebruik van belangrijke subroutine: Partition  Quicksort is langzaam in het slechtste geval, maar snel op random inputs  Randomized-Quicksort om slechte gevallen ‘meestal’ te vermijden  Wiskundige analyse van gemiddelde tijd Randomized-Quicksort

14 14 Quicksort  Verdeel en heers paradigma  Idee is:  Kies een element uit de array, zeg x  Splits de array in drie stukken: Alles in 1 e stuk is  x 2 e stuk is het element x Alles in 3 e stuk is  x (of >)  Sorteer recursief het eerste stuk  Sorteer recursief het derde stuk  Klaar!

15 15 PARTITION Quicksort: Eén Datastructuren

16 16 Splitsen Partition(A,p,r)  {Input is array A met indexwaardes van p tot en met r}  {Output: waarde q met p  q  r zodat A[p..r] een permutatie is van input, en als p  i  q dan geldt A[i] A[q] en als q  i  r dan geldt A[i] A[q]}  …  Methode partitioneert array A[p…r]  Returnwaarde is plek waar “splitselement” terechtgekomen is  Splitselement heet pivot en nemen we nu als element dat op A[r] staat

17 17 Partition  Code in boek is subtiel pivot Allemaal  Allemaal  Gebied waar we nog aan werken ij-1p r i+1j

18 18 Pseudocode Partition Partition(A,p,r)  pivot = A[r];  i = p – 1;  for j = p to r – 1 do  {*}  if A[j]  pivot  then i ++; Verwissel A[i] en A[j]  Verwissel A[i+1] en A[r];  return i+1;  Invariant: bij * geldt voor elke k, p  k  r: 1. Als p  k  i, dan A[k]  pivot 2. Als i+1  k  j – 1, dan A[k]  pivot 3. Als k=r, dan A[k]=pivot

19 19 Pseudocode Partition Partition(A,p,r)  pivot = A[r];  i = p – 1;  for j = p to r – 1 do  {*}  if A[j]  pivot  then i ++; Verwissel A[i] en A[j]  Verwissel A[i+1] en A[r];  return i+1;  Invariant: bij * geldt voor elke k, p  k  r: 1. Als p  k  i, dan A[k]  pivot 2. Als i+1  k  j – 1, dan A[k]  pivot 3. Als k=r, dan A[k]=pivot  Merk op:  Initieel geldt invariant: triviaal  Invariant blijft gelden  Bij terminatie …

20 20 Partition na de loop  En dan verwisselen we A[i+1] en A[r] Allemaal  Allemaal  i p r i+1 Allemaal  Allemaal  i+1 pr

21 21 Looptijd partition Partition(A,p,r)  pivot = A[r];  i = p – 1;  for j = p to r – 1 do  {*}  if A[j]  pivot  then i ++; Verwissel A[i] en A[j]  Verwissel A[i+1] en A[r];  return i+1;  Lineair(r-p+1)  Inspectie van loopstructuur

22 22 Opmerking (herhaling)  In onze beschrijving gingen we er van uit dat alle elementen verschillend zijn  Als er gelijke elementen zijn, werkt het ook, maar moet je iets beter opletten in de analyse (zelfde code kan gebruikt worden) Datastructuren

23 23 CODE EN EERSTE ANALYSE Quicksort: Twee Datastructuren

24 24 Quicksort Quicksort(A, p, r)  {Sorteert het deel van de array A[p…r]}  if p < r  then  q = Partition(A, p, r)  Quicksort(A, p, q-1)  Quicksort(A, q+1, r)

25 25 Allemaal  Allemaal  q r r p p

26 26 Hoeveel tijd kost Quicksort?  In het slechtste geval gaat het erg langzaam…  Bekijk een gesorteerde rij:  We splitsen in stukken van grootte n – 1; 1; 0  En de volgende keer in stukken van grootte n-2; 1; 0  Etc.  Dus: cn+ c(n-1)+ c(n-2)+ c(n-3) + … +3c+2c+c = c n(n+1)/2 stappen  Op een gesorteerde rij: (n 2 ) stappen

27 27 Analyse met recurrente betrekkingen  Schrijf: T(n) is aantal stappen van Quicksort op gesorteerd array met n elementen  T(n) = T(n-1)+T(0) + (n) = T(n-1)+ (n) = (n 2 ) Andere constantes Met inductie naar n

28 28 Quicksort voor aartsoptimisten  Als we echt geluk hebben, splitst Quicksort altijd precies middendoor en gaan we in recursie op twee stukken van hooguit n/2 elementen  Zelfde analyse als bij Mergesort geeft (n lg n) tijd

29 29 log n niveau’s

30 30 Beste geval analyse van Quicksort met recurrente betrekkingen  Stel T(n) is het beste geval van de looptijd van Quicksort op een array met n elementen  T(n)  2*T(n /2) + O(n) (*)  T(n) = O(n lg n)  Volgt uit (*) met inductie  Zo kan je ook Mergesort analyseren

31 31 Quicksort voor optimisten (niet noodzakelijk aartsoptimisten)  Stel nu dat we altijd verdelingen hebben die de array splitsen in twee stukken die verhouding 9 – 1 hebben  T(n) = T(9n / 10)+ T(n / 10) + (n)  Recursieboom heeft log 10/9 n = (lg n) lagen  Per laag (n) dus in zo’n geval eveneens (n lg n)  Maar … hoe vaak gebeurt dat?

32 32 Hoe vaak doen we een goede splitsing?  In 80% van de gevallen splitsen we 9-1 of beter…  Ingewikkelde analyse geeft (n lg n) tijd gemiddeld over alle mogelijke permutaties van input als alle getallen verschillend zijn (doen we niet)

33 33 RANDOMIZED QUICKSORT Drie Datastructuren

34 34 Hoe zorgen we ervoor dat we heel vaak goed splitsen  Idee 1: maak eerst een random permutatie van de input  Geeft (n lg n)  Analyse ingewikkeld  Idee 2 (beter): gebruik niet A[r] als pivot, maar gebruik een random element als pivot  Geeft ook (n lg n)  Analyse eenvoudiger  Ietsje sneller

35 35 Randomized-Partition Randomized-Partition(A,p,r)  Kies uniform een random getal i uit de verzameling {p, p+1, …, r}  Verwissel A[r] en A[i]  Partition(A,p,r) Elk element in A heeft dezelfde kans om als pivot-element gebruikt te worden

36 36 Allemaal  Allemaal  q r r p p

37 37 Quicksort Quicksort(A, p, r)  {Sorteert het deel van de array A[p…r]}  if p < r  then  q = Partition(A, p, r)  Quicksort(A, p, q-1)  Quicksort(A, q+1, r)

38 38 Randomized-Quicksort pseudocode Randomized-Quicksort(A, p, r)  {Sorteert het deel van de array A[p…r]}  if p < r  then  q = Randomized-Partition(A,p,r)  Randomized-Quicksort(A, p, q-1)  Randomized-Quicksort(A, q+1, r)

39 39 Analyse Randomized Quicksort  Verschillende manieren om de verwachtte tijd uit te rekenen  Netjes: stel recurrente betrekking op, en los die op (zie o.a. sheets)  Vandaag: telargument waarbij we kijken naar “hoe vaak doet een element mee in een partition”?

40 40 Tijd is O(som partition-lengtes)  Kijk naar recursieboom  Totale tijd is O(som van alle lengtes van alle deelstukken waar we een partitie op doen)  =  O(som over alle elementen van aantal keren dat het element in een partitie mee doet)

41 41 Verwachtte tijd  Totale verwachtte tijd is O(verwachte som van alle lengtes van alle deelstukken waar we een partitie op doen)  =  O(som over alle elementen van verwachtte aantal keren dat het element in een partitie mee doet)  = n* O(verwachtte aantal keren dat een element in een partitie meedoet)

42 42 Afschatten van verwachtte aantal keren dat een element in een partitie meedoet  Is O(log n)  Hoe laten we dit zien?  Kijk element x, en kijk naar het formaat van het stuk waar x in zit.  Begint met formaat n  Iedere keer een beetje kleiner  Als formaat 1 is zijn we klaar  Hoe vaak is het verwachtte aantal keren dat het kleiner wordt? We laten zien: O(log n)

43 43 Kans is ½ dat stuk hooguit ¾ van oude lengte heeft  Als we een stuk hebben met r elementen zijn er r/2 keuzes voor de pivot die zorgen dat de volgende keer het grootste stuk hooguit ¾ * r lang is

44 44 Tellerij klaar  Hoe vaak kan je n met ¾ vermenigvuldigen totdat je onder de 1 bent?  log 4/3 n keer = O(log n)  Wat is het verwachtte aantal keren dat je een experiment met kans ½ moet doen totdat je s keer succes hebt?  2s  Dus verwachtte aantal keren dat element in partitie meedoet is hooguit 2 log 4/3 n = O(log n) keer  Dus: verwachtte tijd Quicksort O(n log n)  Andere analyse (wel in sheets, niet vandaag):  2n ln n

45 45 Analyse Randomized-Partition  Slechtste geval: weer (n 2 )  T(n) = max 0 q n-1 T(q)+T(n-q-1)+(n)  Verwachtte tijd: analyse doen we hier aannemend dat alle elementen verschillend zijn (anders klopt ‘t ook, overigens)  We doen de analyse hier met behulp van de sommatiefactormethode  Eerst: vergelijking looptijd en aantal vergelijkingen Deze sheet slaan we over

46 46 Looptijd vs aantal vergelijkingen  Stel Quicksort doet X vergelijkingen. Dan gebruikt het O(n+X) tijd  Partition doet altijd minstens 1 vergelijking Want we roepen Partition alleen aan op stukken met minstens 2 elementen  Partition doet O(aantal vergelijkingen in partition) werk  …  We gaan nu het verwachtte aantal vergelijkingen tellen dat Quicksort doet op een array met n verschillende elementen. Noem dit getal C(n) Deze sheet slaan we over

47 47 Technisch detail  We volgen de analyse uit Concrete Mathematics. Die gebruikt twee vergelijkingen per recursieve aanroep extra.  Deze waardes noemen we D(n).  D(0)=C(0)=0; als n>0 dan is D(n)>C(n)  Als we dus voor D(n) een bovengrens hebben, geeft dat ook een bovengrens voor C(n)  Uiteindelijke waarde is dus iets beter (scheelt niet veel) Deze sheet slaan we over

48 48 Aantal vergelijkingen (Randomized)- Partition Partition(A,p,r)  pivot = A[r];  i = p – 1;  for j = p to r – 1 do  {*}  if A[j]  pivot  then i ++; Verwissel A[i] en A[j]  Verwissel A[i+1] en A[r];  return i+1;  n-1 vergelijkingen op een array met n elementen  Concrete Mathematics neemt hier n+1 vergelijkingen Deze sheet slaan we over

49 49 Analyse D(n) (1)  D(0) = 0  D(1) = 2  D(n) = n+1 + ????  Elk van de splitsingen heeft dezelfde kans: 0,1,n-1 1,1,n-2 2,1,n-3 … n-2, 1, 1 n-1, 1, 0 Deze sheet slaan we over

50 50 Analyse D(n) (2)  D(0)= 0  D(1)= 2  D(n) = n+1 + 1/n* k=0 n-1 D(k) + 1/n* k=0 n-1 D(n-k- 1)  Elk van de splitsingen heeft dezelfde kans: 0,1,n-1 1,1,n-2 2,1,n-3 … n-2, 1, 1 n-1, 1, 0  Of: D(n) = n+1 + (2/n)* k=0 n-1 D(k) voor n>0 Deze sheet slaan we over

51 51 - Deze hadden we Maal n nemen Zelfde vergl. voor n-1 Vergelijkingen aftrekken Na vereenvoudigen Deze sheet slaan we over

52 52 Stelsel vergelijkingen  D(0)=0  nD(n) = (n+1)D(n-1)+ 2n  Dit stelsel kunnen we met sommatiefactormethode oplossen  Idee is: vermenigvuldig formule met sommatiefactor s n waarbij s n = (a n-1 a n-2 …a 1 )/(b n b n-1 …b 2 ) als a n D(n)=b n D(n-1)+c n Want dan is s n b n =s n-1 a n-1 En dan krijg je voor E(n)=s n a n D(n) de formule E(n)=E(n-1)+s n c n Wat een somformule voor E en daarna voor D geeft… Deze sheet slaan we over

53 53 D(0)=0 nD(n) = (n+1)D(n-1)+ 2n a n = n b n = n+1 c n = 2n : dit hadden we Definitie toepassen: Alles maal s n : Def.: (*) en (**) geven: (*) (**) Deze sheet slaan we over

54 54 dus We hadden dus Want E(0)=0 Deze sheet slaan we over

55 55 Aantal vergelijkingen randomized quicksort Randomized-Quicksort doet verwacht ongeveer 2(n+1)ln n vergelijkingen Deze sheet slaan we over

56 56 Resultaat en discussie  Het verwachtte aantal vergelijkingen van Randomized-Quicksort is minder dan 2(n+1)ln n  Verwachtte looptijd is (n lg n)  De in de O /  verstopte constante is erg klein, dus heel snel in de praktijk  Sommige hele snelle sorteermethoden switchen naar een ander algoritme wanneer n klein is (bijvoorbeeld onder de 30)

57 57 Recap  Quicksort  Snel sorteer algoritme  Gebruikt gemiddeld weinig tijd: (n lg n) met in de praktijk een kleine constante  Maakt gebruik van belangrijke subroutine: Partition  Quicksort is langzaam in het slechtste geval, maar snel op random inputs  Randomized-Quicksort om slechte gevallen ‘meestal’ te vermijden  Wiskundige analyse van gemiddelde tijd Randomized-Quicksort

58 58 Sorteeralgoritmen overzicht  Slechtste en gemiddeld geval (n 2 ): bubble sort, insertion sort  Slechtste en gemiddeld geval (n lg n): merge sort, heapsort (zometeen)  Slechtste geval (n 2 ) en gemiddeld geval (n lg n): quicksort  Voordeel van Quicksort vooral in de “” verstopt  Geen extra geheugen: bubble sort, insertion sort, heapsort, quicksort  Wel extra geheugen: merge sort


Download ppt "1 Datastructuren Quicksort College 3. 2 Vorige keren  O-notaties  Sorteren: insertion sort, bubble sort  Kosten (n 2 ) tijd in het slechtste geval."

Verwante presentaties


Ads door Google