Zevende college complexiteit. 7 maart Mergesort, Ondergrens sorteren (Quicksort)

Transcriptie

1 College 7 Zevende college complexiteit 7 maart 2017 Mergesort, Ondergrens sorteren (Quicksort) 1

2 Inversies Definitie: een inversie van de permutatie A[1],A[2],...,A[n] is een paar (A[i],A[j]) waarvoor i < j en A[i] > A[j]. M.a.w.: een inversie is een paar (A[i], A[j]) dat verkeerd om staat. Merk op: elk sorteeralgoritme moet alle aanwezige inversies opheffen. Verder: als een sorteeralgoritme altijd hooguit één inversie opheft per arrayvergelijking, dan is het aantal vergelijkingen dat wordt gedaan om A[1],...,A[n] te sorteren ten minste het aantal inversies van A. Bovendien: een buurverwisseling (zoals bij Insertion sort) heft altijd precies één inversie op (indien de buurelementen verkeerd om staan). 2

3 Average case Stelling Het gemiddeld aantal inversies in een permutatie van n verschillende waarden (bijvoorbeeld de getallen 1 t/m n) is 4 1 n(n 1). Dit onder de aanname dat alle n! permutaties even waarschijnlijk zijn. Gevolg: elk algoritme dat sorteert met behulp van arrayvergelijkingen en dat per vergelijking ten hoogste één inversie opheft, moet ten minste 1 4n(n 1) vergelijkingen doen in de average case. Insertion sort doet gemiddeld 1 4 n(n 1) + n 1 n i=2 1 i vergelijkingen, dus Insertion sort is in de average case in orde van grootte optimaal (binnen de betreffende klasse van algoritmen), namelijk Θ(n 2 ). 3

4 Verdeel en heers Mergesort en Quicksort zijn sorteermethoden die allebei gebaseerd zijn op de verdeel-en-heers strategie: Sorteer(rij):: if ( de rij heeft meer dan één element ) then Verdeel de rij in twee stukken: linkerrij en rechterrij; Sorteer(linkerrij); Sorteer(rechterrij); Combineer linkerrij en rechterrij; fi. Mergesort stopt het meeste werk in de Combineer-stap, Quicksort in de Verdeel-stap. Beide sorteermethoden zijn gebaseerd op arrayvergelijkingen, maar doen geen buurverwisselingen, zoals Insertion sort en Bubble sort. 4

5 Mergesort 1 Het (recursieve) Mergesort algoritme: MergeSort(A, p, r):: // sorteert A[p],...,A[r] if p < r then q := p+r 2 ; MergeSort(A, p, q); MergeSort(A,q +1,r); Merge(A,p,q,r); fi verdeel en heers (voeg samen) Aanroep: MergeSort(A, 1, n). 5

6 Mergesort p q r s o r t e e r s o r t e e r... gesorteerd gesorteerd... p q q+1 r voeg samen... gesorteerd... p r 6

7 Samenvoegen Merge(A, p, q, r):: i := p; j := q +1; k := p; while i q and j r do if A[i] < A[j] then hulp[k] := A[i]; i := i+1; k := k +1; else hulp[k] := A[j]; j := j +1; k := k +1; fi od if i > q then // eerste helft is op kopieer A[j],...,A[r] naar hulp; else // tweede helft is op kopieer A[i],...,A[q] naar hulp; fi kopieer hulp[p],...,hulp[r] terug naar A; 7

8 Merge 1 Merge(A,p,q,r) voegt de reeds gesorteerde deelrijtjes A[p],...,A[q] en A[q+1],...,A[r] samen tot een gesorteerd stuk A[p],...,A[r] hulp is een hulparray ter grootte n (net als A) Geheel analoog kan een functie Merge(A, B, C, k, m) geschreven worden die de gesorteerde rijen A (k elementen) en B (m elementen) samenvoegt tot de gesorteerde rij C (n = k +m elementen) 8

9 Merge 2 Voor het bepalen van de complexiteit van Merge tellen we het aantal vergelijkingen van de vorm: A[i] < A[j] Er worden altijd 2n verplaatsingen van array-elementen gedaan Is het aantal arrayvergelijkingen hier wel een goede maat voor de complexiteit? 9

10 Complexiteit Merge Stel dat we met behulp van Merge twee gesorteerde rijtjes van respectievelijk k en m elementen (met k + m = n) samenvoegen tot één gesorteerde rij. Dan geldt: 1. Het aantal vergelijkingen in de worst case is n 1 2. Het aantal vergelijkingen in de best case is min{k, m} Let op: binnen Mergesort is het aantal vergelijkingen een goede maat voor de complexiteit. Immers het aantal vergelijkingen is in dat geval altijd Θ(n), evenals het aantal verplaatsingen van array-elementen. In het algemene geval is dit niet zo (bijvoorbeeld k = 1 en m = n 1). 10

11 Worst case Mergesort Zij T(n) = aantal vergelijkingen in de worst case van Mergesort op n elementen, met n = 2 k. Dan geldt: T(n) = { 0 n = 1 2T( n 2 )+n 1 n = 2k > 1 Oplossing: T(n) = nlgn n+1 Θ(nlgn) 11

12 Worst case Mergesort 2 Als n geen tweemacht is, wordt de recurrente betrekking: T(n) = { 0 n = 1 T( n 2 )+T( n 2 )+n 1 n > 1 Dan geldt eveneens: T(n) Θ(nlgn). Je kunt zelfs bewijzen: T(n) = n lgn 2 lgn +1 Mergesort is in orde van grootte optimaal voor wat betreft de worst case (immers: de ondergrens voor sorteren via arrayvergelijkingen is Ω(n lg n)). Er is echter extra geheugenruimte ter grootte Θ(n) nodig. 12

13 Best case Mergesort Zij B(n) = aantal vergelijkingen in de best case, met n = 2 k. Dan geldt: B(n) = { 0 n = 1 2B( n 2 )+ n 2 n = 2k > 1 Oplossing: B(n) = n 2 lgn Θ(nlgn). 13

14 Optimaliteit Merge Stelling 1. Elk algoritme gebaseerd op arrayvergelijkingen dat twee gesorteerde arrays (rijen) van lengte m samenvoegt tot één gesorteerd array, doet in het slechtste geval ten minste 2m 1 van zulke vergelijkingen. Voor m = n 2 (n even) is dit dus ten minste n Voor het samenvoegen van twee rijtjes ter lengte m 1 respectievelijk m is dat ten minste 2m 2. Voor m = n 2 (n oneven) is dit ten minste n 1. Gevolg. Binnen de klasse van samenvoegalgoritmen gebaseerd op arrayvergelijkingen is het beschreven Mergealgoritme optimaal, althans voor twee ongeveer even lange rijtjes. 14

15 Bewijs We geven een klasse van invoerrijtjes waarop elk samenvoegalgoritme (gebaseerd op arrayvergelijkingen) ten minste 2m 1 vergelijkingen moet doen. Dat bewijst dan de stelling. Kies stijgende rijtjes A = (a 1,a 2,...,a m ) en B = (b 1,b 2,...,b m ) zó dat alle a i en b j verschillend zijn en a i < b j i < j: b 1 < a 1 < b 2 < < a i 1 < b i < a i < b i+1 < < b m < a m Dan moet elk samenvoegalgoritme a i met b i vergelijken (i = 1,2,...,m) en a i met b i+1 (i = 1,2,...,m 1). Het bewijs van deze bewering gaat uit het ongerijmde. 15

16 Sorteren (ondergrens) We bekijken sorteeralgoritmen gebaseerd op het doen van vergelijkingen van de vorm A[i] < A[j]. Aannames (z.b.d.a.): - A bevat n verschillende waarden. (We gaan immers een ondergrens voor de worst case bepalen.) - het sorteeralgoritme stopt zodra de sortering (onderlinge ordening) gevonden is. Zo n algoritme correspondeert (voor elke n) met een beslissingsboom die de series vergelijkingen representeert die het algoritme uitvoert voor elke mogelijke invoer (ter grootte n). Elk pad van de wortel tot een blad correspondeert met een executie van het algoritme. 16

17 Beslissingsboom sorteren algoritme gebaseerd op het doen van arrayvergelijkingen A[i] < A[j] beslissingsboom : binaire boom waarin de interne knopen corresponderen met arrayvergelijkingen en de bladeren/externe knopen met het eindresultaat ; een pad vanaf de wortel naar een blad correspondeert met een executie van het algoritme alle A[i] zijn verschillend eindresultaat = de gevonden sortering/ordening (in dit geval) 17

18 Beslissingsboom A[i] < A[j] p : q i : j vergelijk A[i] en A[j] A[i] > A[j] r : s vergelijk vervolgens A[p] en A[q] vergelijk vervolgens A[r] en A[s] Beslissingsboom voor algoritmen gebaseerd op arrayvergelijkingen 18

19 Insertion sort 1 : 2 2 : 3 1 : 3 1,2,3 1 : 3 2,1,3 2 : 3 1,3,2 3,1,2 2,3,1 3,2,1 Beslissingsboom voor Insertion sort met n = 3 2,3,1 betekent: A[2] < A[3] < A[1] (analoog de andere bladeren) 19

20 Hoogte worst case 1 : 2 niveau 0 2 : 3 1 : 3 niveau 1 1,2,3 1 : 3 2,1,3 2 : 3 niveau 2 1,3,2 3,1,2 2,3,1 3,2,1 niveau 3 In een beslissingsboom voor algoritmen gebaseerd op arrayvergelijkingen geeft de hoogte van de boom precies het aantal vergelijkingen in de worst case aan. 20

21 Bladeren: maximaal 1. - alleen de onderlinge volgorde van de array-elementen wordt onderscheiden; niet de waarde - het rijtje 6,11,15,8,3 wordt bijvoorbeeld precies zo behandeld door het sorteeralgoritme als het rijtje 2,4,5,3,1 - ze volgen dan ook precies hetzelfde pad in de beslissingsboom - er zijn in essentie n! mogelijke te onderscheiden invoeren, die elk één pad volgen in de boom er zijn maximaal n! bladeren 21

22 Bladeren: minimaal 2. - sorteren = vind de oplopende ordening - er zijn dus n! verschillende eindantwoorden (=ordeningen) mogelijk - een sorteeralgoritme moet die allemaal kunnen vinden - de bijbehorende beslissingsboom moet dus minstens n! bladeren hebben 3. Conclusie: een beslissingsboom corresponderend met een sorteeralgoritme gebaseerd op arrayvergelijkingen heeft precies n! bladeren (n = aantal array-elementen) 22

23 Ondergrens sorteren Stelling Het aantal vergelijkingen in de worst case is voor elk algoritme dat sorteert middels arrayvergelijkingen ten minste lgn! (dus Ω(nlgn)). Stelling Het aantal vergelijkingen in de average case is voor elk algoritme dat sorteert middels arrayvergelijkingen Ω(n lg n). Dit onder de aanname dat alle n! mogelijke volgordes als invoerrijtje even waarschijnlijk zijn. De stelling volgt direct uit de resultaten van de volgende sheet. 23

24 Intermezzo Gegeven een binaire boom B met b bladeren. Definitie. De externe padlengte E van B is de som van de lengtes van alle paden van de wortel naar een blad: E = Σ bladeren (lengte pad wortel blad) Lemma. Zij E de externe padlengte van B. Dan geldt: E b ( lgb 1) Gevolg. De gemiddelde lengte van een pad van de wortel naar een blad = E b lgb 1. 24

25 Verdeel en heers Mergesort en Quicksort zijn sorteermethoden die allebei gebaseerd zijn op de verdeel-en-heers strategie: Sorteer(rij):: if ( de rij heeft meer dan één element ) then Verdeel de rij in twee stukken: linkerrij en rechterrij; Sorteer(linkerrij); Sorteer(rechterrij); Combineer linkerrij en rechterrij; fi. Mergesort stopt het meeste werk in de Combineer-stap, Quicksort in de Verdeel-stap. Beide sorteermethoden zijn gebaseerd op arrayvergelijkingen, maar doen geen buurverwisselingen, zoals Insertion sort en Bubble sort. 25

26 Quicksort (Hoare 1962) QuickSort(A, p, r):: // sorteert A[p],...,A[r] oplopend if p < r then q := Partitie(A,p,r); QuickSort(A, p, q); QuickSort(A,q +1,r); fi Aanroep: Quicksort(A,1,n) - recursief - alleen interne verwisselingen - geen extra geheugenruimte - in de praktijk een van de snelste 26

27 Quicksort... x... p Partitie r p q r x x Quicksort Quicksort... gesorteerd, x gesorteerd, x... p q r 27

28 Partitie Partitie (A, p, r):: // reorganiseert het (deel)array A[p],...,A[r] als volgt:.. x x.. p q r (*) // hier komt nog wat x = A[p]; i := p 1; j := r +1; while i < j do j := j 1; while A[j] > x do j := j 1; od i := i+1; while A[i] < x do i := i+1; od if i < j then wissel(a[i],a[j]); fi od return j; // loop met j naar links // tot je een waarde A[j] x vindt // loop met i naar rechts // tot je een waarde A[i] x vindt // A[i] en A[j] staan nu weer in het goede stuk // dit wordt dus q 28

29 Opmerkingen bij Partitie 1. De basisoperatie is het vergelijken van array-elementen: A[j] > x en A[i] < x 2. Partitie stopt met i = j of i = j Na afloop is altijd j p en j r 1, dus p q r 1. Quicksort wordt dus op echt kleinere rijtjes recursief aangeroepen 4. Elk array-element wordt precies één keer met x vergeleken, behalve A[q] (twee keer) en eventueel A[q + 1] (soms twee keer) 5. Partitie doet altijd Θ(m) vergelijkingen, nl. m + 1 of m+2, met m het aantal elementen van het (deel)array A[p],...,A[r] 6. Er worden elementen verwisseld die ver uit elkaar kunnen liggen. Per vergelijking worden dus wellicht > 1 inversies opgeheven 29

30 Werking Partitie Na een volledige ronde: p r.... i }{{} x j }{{} x 2. Na de j-loop: p r.. x.. i }{{} x j A[j] x 30

31 Werking Partitie Na de i-loop, vóór de verwisseling: p r.. x x.. i j A[i] x A[j] x 4. Na de verwisseling: p r.... }{{} x i j }{{} x 31

32 (Werk)college - Volgende college: dinsdag 21 maart, 11:15 13:00, zaal 174 (en dan verder met Quicksort, Shellsort,...) - Eerstvolgende werkcollege: dinsdag 7 maart, 13:45 15:30, zaal Tweede huiswerkopgave: liacs.leidenuniv.nl/ graafjmde/comp/ - Inleveren: uiterlijk dinsdag 28 maart