1 Sortering

2 Plan Elementære metoder til sortering -sortering ved indsættelse -Shellsort Sorteringsmetoder baseret på rekursion –quicksort –flettesortering Randomisering

3 Hvorfor sortere? (1) Det er lettere at søge i en en sorteret datamængde end i en usorteret datamængde, såvel for maskiner som for mennesker. Tænk f.eks. på opslag i en telefonbog. (2) Mange problemer kan løses mere effektivt, hvis inddata er sorteret. Eksempel: Hvis to filer er sorteret i samme orden, er det muligt i blot ét gennemløb at finde alle de poster, der findes i begge filer. Uformel definition: Ved sortering forstås en proces, hvorved elementerne i en datamængde ordnes i rangfølge.

4 Bestemmelse af fællesmængden for to usorterede arrays k = 0; for (i = 1; i <= M; i++) for (j = 1; j <= N; j++) if (a[i] == b[j]) c[++k] = a[i]; Kompleksitet: O(M * N) i a: M1 j b: 1 N k c: 1

5 k = 0; i = j = 1; while (i <= M && j <= N) if (a[i] < b[j]) i++; else if (a[i] > b[j]) j++; else { c[++k] = a[i]; i++; j++; } Bestemmelse af fællesmængden for to sorterede arrays Kompleksitet: O(M + N) i a: M1 < j b: 1 N < k c: 1 <

6 Permutationer En permutation af en mængde af objekter er en ordning af objekterne. For eksempel er p = (2 3 1) en permutation af {1, 2, 3}. p(1) = 2 p(2) = 3p(3) = 1 Der er 6 permutationer af {1, 2, 3}, nemlig (1 2 3)(1 3 2)(2 1 3)(2 3 1)(3 1 2) (3 2 1) Antallet af permutationer af n objekter er n!.

7 Lad der desuden være defineret en ordningsrelation ‘<’ på mængden af nøgleværdier, som er total, dvs. for vilkårlige tre nøgleværdier a, b og c opfylder følgende to betingelser: (1) Præcis et af følgende 3 udsagn er sandt: a < b, a = b eller b < a (3-delelighed) (2) Hvis a < b og b < c, så a < c(transitivitet) Lad der være givet N emner R 1, R 2,..., R N, der skal sorteres. Vi kalder dem poster, og hele samlingen kaldes for en fil. Hver post R i indeholder en nøgle, K i, til styring af sorteringen. Herudover kan en post indeholde anden information. En sortering af en fil af n poster er en permutation, p, af mængden {1, 2,..., n}, som ordner nøglerne i stigende rækkefølge: K p(1) ≤ K p(2) ≤... ≤ K p(N).

8 En sortering af en fil i det indre lager (f.eks. et array), kaldes for intern sortering. En sortering af en fil på et eksternt lagermedium (f.eks. en disk) kaldes for ekstern sortering. Terminologi

9 Elementære algoritmer Sortering ved indsættelse Shellsort Hvorfor studere elementære algoritmer? (1) De er lette at kode (2) De er (tilstrækkeligt) hurtige for små filer (3) I specielle situationer er de hurtigst (4) Udgør illustrative eksempler på algoritmedesign og -analyse

10 Problem: Givet et array a med elementerne a[1], a[2],..., a[n]. Sorter elementerne i stigende orden. Sortering ved indsættelse Løsning (ved induktion): Basistilfælde: Vi ved, hvordan 1 element sorteres. Induktionshypotese: Vi ved, hvordan n-1 elementer sorteres. Vi kan opnå en sortering af n elementer ved (1) at sortere de første n-1 elementer, (2) indsætte det n´te element korrekt blandt disse.

11 A S O R T I N G E X A M P L E A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A I O R S T N G E X A M P L E A I N O R S T G E X A M P L E A G I N O R S T E X A M P L E A E G I N O R S T X A M P L E A A E G I N O R S T X M P L E A A E G I M N O R S T X P L E A A E G I M N O P R S T X L E A A E G I L M N O P R S T X E A A E E G I L M N O P R S T X

12 Animering af sortering ved indsættelse

13 void insertionSort(Comparable a[], int i) { if (i > 0) { insertionSort(a, i-1); for (int j = i; j > 0 && a[j].lessThan(a[j-1]); j--) swap(a, j, j-1); } Sortering ved indsættelse (rekursiv udgave) void swap(Object a[], int i, int j) { Object tmp = a[i]; a[i] = a[j]; a[j] = tmp; }

14 void insertionSort(Comparable a[]) { for (int i = 1; i < a.length; i++) { for (int j = i; j > 0 && a[j].lessThan(a[j-1]); j--) swap(a, j, j-1); } Sortering ved indsættelse (iterativ udgave)

15 void insertionSort(Comparable a[], int i) { for (int i = 1; i < a.length; i++){ Comparable tmp = a[i]; int j = i; while (j > 0 && tmp.lessThan(a[j-1])) { a[j] = a[j-1]; j--; } a[j] = tmp; } Sortering ved indsættelse (iterativ udgave med flytninger) tmp: i a: 0 j-1j

16 Analyse af sortering ved indsættelse Antal sammenligninger: Bedste tilfælde: n-1 Værste tilfælde: (n-1) = n(n-1)/2 = O(n 2 ) Gennemsnitlige tilfælde: n(n-1)/4 = O(n 2 ) Antal flytninger: Bedste tilfælde: 0 Værste tilfælde: (n-1) = n(n-1)/2 = O(n 2 ) Gennemsnitlige tilfælde: n(n-1)/8 = O(n 2 ) Tidsforbruget er lineært for “næsten sorterede” filer.

17 Shellsort (D. L. Shell, 1959) Ide: Sortering ved indsættelse er meget effektiv, når filen er “næsten sorteret”. Men for “meget usorterede” filer er den langsom, da den kun tillader ombytning af naboelementer. Spørgsmål: Kan vi sørge for at ombytte elementer, der ligger langt fra hinanden i starten, for så derefter at foretage en sædvanlig sortering ved indsættelse? Svar: Ja, vi kan sortere de delfiler, der fås ved at tage hvert h´te element i den oprindelige fil, hvor h > 1.

18 4-sortering 1. Opdel filen i 4 delfiler: hvert 4. element startende i det første, hvert 4. element startende i det andet, hvert 4. element startende i det tredje, hvert 4. element startende i det fjerde, 2. Sorter hver af disse. Filen siges da at være 4-sorteret. På tilsvarende måde kan vi definere en h-sortering. Bemærkning: En fil, der er 1-sorteret, er sorteret.

19 4-sortering ved indsættelse Benyt sortering ved indsættelse med “skridtlængde” 4. A S O R T I N G E X A M P L E A I O R T S N G E X A M P L E A I N R T S O G E X A M P L E A I N G T S O R E X A M P L E A I N G E S O R T X A M P L E A I A G E S N R T X O M P L E A I A G E S N M T X O R P L E A I A G E S N M P X O R T L E A I A G E L N M P S O R T X E A I A G E L E M P S N R T X O

20 h-sortering void h_sort(int a[], int h) { for (int i = h; i < a.length; i++) { Comparable tmp = a[i]; int j = i; while (j >= h && tmp.lessThan(a[j-h])) { a[j] = a[j-h]; j -= h; } a[j] = tmp; } I forhold til insertionSort er 1 blot erstattet med h.

21 void shellsort(int a[]) { int h; for (h = 1; h < a.lenghth/9; h = 3*h + 1) ; for ( ; h >= 1; h /= 3) h_sort(a, h); } Shellsort Shellsort er h-sortering for en aftagende sekvens af h-værdier, afsluttende med h = 1. I dette tilfælde sekvensen..., 1093, 364, 121, 40, 13, 4, 1. Det er en god ide, at vælge sekvenser, hvor successive værdier er indbyrdes primiske (deres største fælles divisor er 1).

22 void shellsort(int a[]) { for (int h = a.length/2; h > 0; h = h == 2 ? 1 : h/2.2) h_sort(a, h); } Shellsort Lærebogens algoritme:

23 Animering af Shellsort

24 Analyse af Shellsort Antal sammenligninger: Bedste tilfælde: (n-1) + (n-4) + (n-13) +... ≤ n log 3 n Værste tilfælde: højst n 1.5 (for sekvensen 1, 4, 13,...) Gennemsnitlige tilfælde: kendes ikke. To forslag er O(n 1.25 ) og O(n(log n) 2 ). Antal flytninger: Bedste tilfælde: 0 Værste tilfælde: højst n 1.5 (for sekvensen 1, 4, 13,...) Gennemsnitlige tilfælde: kendes ikke. To forslag er O(n 1.25 ) og O(n(log n) 2 ).

25 Har du brug for en sorteringsmetode? Så brug Shellsort. lidt kode bedste metode til små og middelstore filer stadig OK for meget store filer

26 Java (JIT), tid i sekunder: metode N = insertionSort shellsort Måling af køretider (PowerBook G3, 400 MHz, Metrowerks) C, tid i sekunder: metode N = insertionSort shellsort

27 At en metode er stabil kan være hensigtsmæssigt ved sortering på flere nøgler. Hans 9Arne 9Jørgen03 Karen11Erling 11Mette 7 Jørgen03Hans 9Niels 7 Niels 7Jørgen03Arne 9 Mette 7Karen11Hans 9 Arne 9Mette 7Erling 11 Erling 11Niels 7Karen11 Sorter på første nøgle. Derefter på anden. For samme anden nøgle bevares rækkefølgen fra første sortering. Stabile metoder En sorteringsmetode siges at være stabil, hvis den bevarer den relative orden af poster med samme nøgle i filen.

28 Quicksort (C. A. R. Hoare, 1962) Quicksort er i praksis den hurtigste algoritme til intern sortering. Desuden er den forholdsvis let at implementere. Ide: For at sortere et array, så del det i en venstre og en højre del, således at alle elementer i den venstre del er mindre end alle elementer i den højre del. Sorter derefter den venstre del og den højre del rekursivt. venstre delhøjre del ≤

29 Deling (partition) Delingen af et array a kan foretages således: (1)Vælg en delingsværdi, v, blandt værdierne i a. (2)Gennemløb a fra venstre mod højre, indtil der findes et element a[i] ≥ v. (3)Gennemløb a fra højre mod venstre, indtil der findes et element a[j] ≤ v. (4) Ombyt a[i] og a[j]. (5)Fortsæt med at gennemløbe og ombytte, indtil de to gennemløb “krydser” hinanden.

30 v: delingsværdien i: venstre-mod-højre-pegeren j: højre-mod-venstre-pegeren i j ≤ v ≥ v a[i] ≥ va[j] ≤ v XY i j ≤ v ≥ v YX ≤ v≥ v

31 Deling af a[low:high] med hensyn til v : i = low; j = high; while (i <= j) { while (a[i].lessThan(v)) i++; while (v.lessThan(a[j])) j--; if (i <= j) { swap(a, i, j); i++; j--; } } Implementering Resultat: a[low:i] ≤ a[j:high] og i > j. Kan bevises ved at påvise gyldigheden af løkkeinvarianten { a[low:i-1] ≤ v ≤ a[j+1:high] } for den yderste løkke.

32 void quicksort(Comparable a[], int low, int high) { if (low < high) { Comparable v = a[(low + high)/2]; int i = low, j = high; while (true) { while (a[i].lessThan(v)) i++; while (v.lessThan(a[j])) j--; if (i >= j) break; swap(a, i, j); i++; j--; } quicksort(a, low, j); quicksort(a, i, high); } Quicksort Delingsværdien v (også kaldet pivot-værdien) kan være værdien af et vilkårligt element blandt a[low:high], f.eks. a[(low+high)/2].

33 int partition(Comparable a[], int low, int high) { Comparable v = a[high]; int i = low-1, j = high; while (true) { while (a[++i].lessThan(v)) ; while (v.lessThan(a[--j])) if (j == low) break; if (i >= j) break; swap(a, i, j); } swap(a, i, high); return i; } Alternativ implementering af delingen Vi kan alternativt anvende a[high] som delingsværdi. a[low:high-1] deles, hvorefter a[high] ombyttes med a[i].

34 int quicksort(Comparable a[], int low, int high) { if (low < high) { int i = partition(a, low, high); quicksort(a, low, i-1); quicksort(a, i+1, high); } Metoden quicksort

35 Animering af quicksort

36 Antal sammenligninger Lad C(N) betegne antallet af sammenligninger ved kald af quicksort med N elementer (N = high-low+1 ). Ved delingen foretages cirka N sammenligninger. Herefter sorteres den venstre del og den højre del hver for sig. I gennemsnit består hver del af cirka N/2 elementer, og får vi derfor rekursionsrelationen: C(N) = N + 2*C(N/2) for N ≥ 2, og C(1) = 0. som har løsningen C(N) = N log 2 N.

37 Mere præcise beregninger giver Quicksort bruger i gennemsnit cirka 2N lnN sammenligninger. hvor ln betegner den naturlige logaritme. Antal sammenligninger i gennemsnit 2N ln N ≈ 1.38 N log 2 N Det gennemsnitlige antal sammenligninger er altså kun 38% højere end antallet af sammenligninger i det bedste tilfælde.

38 Antal sammenligninger i værste tilfælde Det værste tilfælde optræder, når delingen for hvert N resulterer i en del med 1 element og en del med N-1 elementer. Vi få da C(N) = N + C(N-1), for N ≥ 2, og C(1) = 0. som har løsningen C(N) = N(N+1)/2. Det værste tilfælde optræder, når filen er sorteret (eventuelt i omvendt orden). Valg af tilfældigt delingselement (eller “median af 3”) reducerer chancen for, at det værste tilfælde optræder.

39 void quicksort(Comparable a[], int low, int high) { if (low < high) { if (a[high].lessThan(a[low])) swap(a, low, high); int mid = (low + high)/2; if (mid == low) return; if (a[mid].lessThan(a[low])) swap(a, low, mid); if (a[high].lessThan(a[mid])) swap(a, mid, high); swap(a, mid, high-1); int i = partition(a, low+1, high-1); quicksort(a, low, i-1); quicksort(a, i+1, high); } Quicksort med median af 3

40 Kravet til ekstra plads er proportionalt med den maksimale stakdybde for de rekursive kald af quicksort. I værste fald kan stakdybden blive N. Nemlig når enhver deling bevirker, at den højre del består af 1 element. Kravet til stakplads kan mindskes (til log 2 N) ved altid først at sortere den mindste af de to dele: Pladskrav if (high-i < i-low) { quicksort(a, i+1, high); quicksort(a, low, i-1); } else { quicksort(a, low, i-1); quicksort(a, i+1, high); } Dog kun under forudsætning af, at der foretages elimination af halerekursion.

41 Quicksort er relativt langsom for små filer, bl.a. på grund af de rekursive kald. Rekursionen kan helt fjernes (ved brug af eksplicit stak). Fjernelse af rekursion void quicksort(Comparable a[], int low, int high) { Stack s = new Stack(50); while (true) { while (low < high) { int i = partition(a, low, high); if (high-i < i-low) { s.push2(low, i-1); low = i+1; } else { s.push2(i+1, high); high = i-1; } } if (s.isEmpty()) return; high = s.pop(); low = s.pop(); }

42 Benyt en simpel metode for små delfiler Langt mere effekt har anvendelse af ‘sortering ved indsættelse’ for “relativt små” delfiler. if (high - low < CUTOFF) insertionSort(a, low, high); else indsættes i stedet for if (low < high) i starten af quicksort, hvor CUTOFF f.eks. er 10.

43 Animering af quicksort (ignorering af små delfiler)

44 Tid i sekunder: Metode N = quicksort shellsort insertionSort ≈ 8 min ≈ 32 min ≈ 2 timer quicksort: median af 3 og insertionSort for små delfiler (CUTOFF = 10). Empirisk undersøgelse af quicksort (PowerBook G3, 400 MHz, Metrowerks)

45 Udvælgelse Problem: Find det k’te mindste element blandt en mængde af N elementer. Eksempel: Det 3. mindste tal blandt {3, 6, 5, 2, 8, 4} er 4. Løsningsmulighed 1: Sorter elementerne i stigende orden. Det k´te element i den sorterede rækkefølge er løsning på problemet. Kompleksitet: afhænger af sorteringsmetode - med quicksort: O(N log N).

46 Løsningsmulighed 2: Hvis k er lille, så anvend sortering ved udvælgelse, men stop, når de første k elementer er på plads. Kompleksitet: O(k N), idet N + (N-1) + … + (N - k + 1) ≈ k N Løsningsmulighed 3: Anvend en “hob” (en datastruktur til repræsentation af prioritetskøer - mere herom senere). Kompleksitet: O(k log N) Kan vi gøre det bedre?

47 Udvælgelse ved brug af partition Metoden omordner a, så a[low:k-1] ≤ a[k] ≤ a[k+1:high]. void quickSelect(Comparable a[], int low, int high, int k) { if (low < high) { int i = partition(a, low, high); if (i > k) quickSelect(a, low, i-1, k); if (i < k) quickSelect(a, i+1, high, k); } Da der kun benyttes halerekursion, kan rekursionen let elimineres: void quickSelect(Comparable a[], int low, int high, int k) { while (low < high) { int i = partition(a, low, high); if (i >= k) high = i-1; if (i <= k) low = i+1; }

48 O(N) i gennemsnit, idet N + N/2 + N/4 + … ≤ 2N. Det er muligt (men ikke helt let) at sørge for garanteret lineær køretid. Kompleksitet af quickSelect

49 void sort(Comparable a[], int low, int high) { if (low < high) { // Del: Del a[low:high] i to delfiler, a[low:i] og a[j:high], hvor i ≥ j. // Hersk: sort(a, low, i); sort(a, j, high); // Kombiner:Sammensæt de to sorterede delfiler, så de udgør en sortering af a[low:high]. } Sortering ved del-og-hersk Mergesort (sortering ved fletning): Del: i = (low+high)/2; j = i+1; Kombiner: Flet de to sorterede delfiler, og placer resultatet i a[low:high]. Quicksort: Del: Vælg en værdi, v. Ombyt elementerne i a[low:high], således at a[low:i] ≤ v ≤ a[j:high], og i ≥ j. Kombiner : Intet.

50 Fletning for (i = j = k = 1; k <= M+N; k++) if (i > M) c[k] = b[j++]; else if (j > N) c[k] = a[i++]; else c[k] = a[i].lessThan(b[j]) ? a[i++] : b[j++]; k c: 1M+N ≤ i a: M1 ≤ ≤ j b: 1N ≤ ≤

51 void mergeSort(Comparable a[], int low, int high) { if (low < high) { int mid = (low + high)/2; mergesort(a, low, mid); mergesort(a, mid+1, high); merge(a, low, mid, high); } mergeSort

52 void merge(Comparable a[], int low, int mid, int high) { int i = low, j = mid+1; for (int k = low; k <= high; k++) if (i > mid) b[k] = a[j++]; else if (j > high) b[k] = a[i++]; else b[k] = a[i].lessThan(a[j]) ? a[i++] : a[j++]; for (int k = low; k <= high; k++) a[k] = b[k]; } Fletning af a[low:mid] med a[mid+1:high] over i a[low:high] : Simpel fletning low mid mid+1 high ≤≤ a:a: ≤ b:b: low high Fletning: ≤ a:a: low high Kopiering:

53 A S O R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S I T N G E X A M P L E A O R S I T G N E X A M P L E A O R S G I N T E X A M P L E A G I N O R S T E X A M P L E A G I N O R S T A E M X P L E A G I N O R S T A E M L L P E A G I N O R S T A E M L E L P A G I N O R S T A E E L M P X A A E E G I L M N O P R S T X

54 Animering af mergesort

55 Kaldtræer

56 Vurdering af sortering ved fletning Fordele: er ufølsom over for startorden i inddata kræver cirka N log 2 N sammenligninger for at sortere enhver fil C(N) = 2C(N/2) + N, C(1) = 0 er stabil kan benyttes til at sortere lister er velegnet til ekstern sortering Ulemper: kræver (i praksis) ekstra plads proportional med N

57 Tid i sekunder: Metode N = mergesort quicksort shellsort Empirisk undersøgelse af mergesort

58 Uformelt bevis: Sortering er ækvivalent med bestemmelse af en permutation. Sortering kan derfor modelleres ved et beslutningstræ, hvor hver interne knude svarer til en sammenligning af to nøgler, mens hver eksterne knude svarer til en af de N! mulige permutationer. Højden i dette træ er mindst log 2 (N!). Af Stirlings formel fås log 2 (N!) ≈ Nlog 2 N N. Kompleksiteten af sortering Enhver sorteringsalgoritme, der er baseret på nøglesammenligninger, kræver i værste tilfælde mindst cNlog 2 N sammenligninger for at sortere N elementer, hvor c er en konstant > 0.

59 Kriterier for valg af sorteringsmetode Størrelse af nøgler (sammenligninger) Størrelse af poster (flytninger/ombytninger) Størrelse af fil (elementær/avanceret metode) Nøgletype (sammenligninger/radix) Mange ens nøgler? Er filen næsten sorteret? Kræves stabilitet?

60 Randomisering

61 Behovet for tilfældige tal Mange anvendelser: Programafprøvning (generering af tilfældige inddata) Sortering (f.eks. bestemmelse af pivot-elementet i quicksort) Simulering (f.eks. generering af kunder i en bank) Spil Randomiserede algoritmer (f.eks. test af om et tal er et primtal)

62 Generering af tilfældige tal Ægte tilfældighed på en computer er umuligt at opnå. Vi må nøjes med pseudotilfældige tal, d.v.s. tal der forekommer at være tilfældige. Sekvenser af genererede tal skal kunne modstå en lang række statistiske tests. For det meste benyttes en lineær kongruens generator (Lehmer, 1951): X i+1 = AX i + B (mod M) hvor X i+1, X i, A, B og M er heltal. X 0 kaldes for generatorens sæd.

63 Generering af tilfældige tal i Java Java tilbyder klassen java.util.Random. public class Random { public Random(); public Random(long seed); public int nextInt(); public long nextLong(); public float nextFloat(); public double nextDouble(); public double nextBytes(byte[] bytes); public double nextGaussian(); public void setSeed(long seed); protected int next(int bits); }

64 public class Random { private long seed; private final static long multiplier = 0x5DEECE66DL;// = private final static long addend = 0xBL;// = 11 private final static long mask = (1L << 48) - 1; public Random() { this(System.currentTimeMillis()); } public Random(long seed) { this.seed = (seed ^ multiplier) & mask; } public int nextInt() { return next(32); } protected int next(int bits) { long nextseed = (seed * multiplier + addend) & mask; seed = nextseed; return (int) (nextseed >>> (48 - bits)); } Til generering af tilfældige heltal benyttes Lehmers metode

65 Generering af tilfældige permutationer (kan f.eks. benyttes til blanding af kort) int randInt(int low, int high) { double min = Integer.MIN_VALUE, max = Integer.MAX_VALUE; double size = (max - min)/(high - low + 1); return (int) (low + (nextInt() - min)/size); } void permute(Object[] a) { Random r = new Random(); for (int i = 1; i < a.length; i++) swap(a, i, r.randInt(0, i)); }

66 Læs kapitel 10 og 11 i lærebogen (side ) Løs følgende opgaver 4-1. Opgave Opgave Opgave Opgave Opgave Opgave Opgave 9.13 Ugeseddel 4 2. oktober - 9. oktober