1 Sortering I elementære metoder

2 Plan Terminologi Elementære metoder til sortering -sortering ved udvælgelse -sortering ved indsættelse -Shellsort -sortering ved tælling - sortering ved adresseberegning

3 Uformel definition: Ved sortering forstås en proces, hvorved elementerne i en datamængde ordnes i rangfølge. Hvorfor sortere? (1) Det er lettere at søge i en en sorteret data- mæ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.

4 Bestemmelse af fællesmængden for to usorterede arrays i a: j b: k c: M1 1 N 1 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)

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 i a: j b: k c: M1 1 N 1 < < < Kompleksitet: O(M + N)

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 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. 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(associativitet) En sortering af en fil af poster er en permutation, p(1), p(2),..., p(N), som ordner nøglerne i stigende rækkefølge, dvs. 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 lager- medium kaldes for ekstern sortering. [behandles ikke] Terminologi

9 Elementære algoritmer Sortering ved udvælgelse Sortering ved indsættelse Boble-sortering Shellsort Sortering ved tælling Sortering ved adresseberegning 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å algoritme- design og analyse

10 Problem: Givet et array a med elementerne a[1], a[2],..., a[n]. Sorter elementerne i stigende orden. Sortering ved udvælgelse 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 udvælge det “minimale” element, (2) sætte det først blandt elementerne, og (3) sortere de sidste n-1 elementer.

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

12 Animering af sortering ved udvælgelse

13 void selection(int a[], int i, int n) { if (i < n) { int min = i; for (int j = i+1; j <= n; j++) if (a[j] < a[min]) min = j; swap(a, min, i); selection(a, i+1, n); } Sortering ved udvælgelse (rekursiv udgave) Metoden swap benyttes til at ombytte elementerne i arrayet: void swap(int a[], int i, int j) { int t = a[i]; a[i] = a[j]; a[j] = t; }

14 void selection(int a[], int n) { for (int i = 1; i < n; i++) { int min = i; for (int j = i+1; j <= n; j++) if (a[j] < a[min]) min = j; swap(a, min, i); } Sortering ved udvælgelse (iterativ udgave)

15 Analyse af sortering ved udvælgelse Antal sammenligninger: Bedste tilfælde: (n-1) = n(n-1)/2 = O(n 2 ) Værste tilfælde: (n-1) = n(n-1)/2 = O(n 2 ) Gennemsnitlige tilfælde: n(n-1)/2 = O(n 2 ) Antal ombytninger: Bedste tilfælde: n-1 (0, hvis ombytninger uden effekt udelades ( min == i )) Værste tilfælde: n-1 Gennemsnitlige tilfælde: n-1 Sortering ved udvælgelse har et tidsforbrug, der stort set ikke afhænger af rækkefølgen i input. Sortering ved udvælgelse er lineær for store poster og små nøgler.

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

17 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

18 Animering af sortering ved indsættelse

19 void insertion(int a[], int i) { if (i > 1) { insertion(a, i-1); int v = a[i]; int j = i; while (j > 1 && a[j-1] > v) { a[j] = a[j-1]; j--; } a[j] = v; } Sortering ved indsættelse (rekursiv udgave) i a: 1j-1j v:

20 void insertionSort(int a[], int n) { for (int i = 2; i <= n; i++) { int v = a[i]; int j = i; while (j > 1 && a[j-1] > v) { a[j] = a[j-1]; j--; } a[j] = v; } Sortering ved indsættelse (iterativ udgave) Løkketesten i den indre løkke kan forsimples til while (a[j-1] > v) hvis a[0] < a[1:n].

21 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 ) Sortering ved indsættelse er lineær for “næsten sorterede” filer.

22 Ide: Hvis arrayet gennemløbes baglæns, og hvert successivt elementpar, (a[j-1],a[j]), n ≥ j > 1, som ikke er ordnet korrekt, ombyttes undervejs, vil det mindste element blive placeret som a[1]. På samme måde kan a[2],..., a[n] successivt tildeles værdier. Boble-sortering (en dårlig metode) void bubble(int a[], int n) { for (int i = 1; i < n; i++) for (int j = n; j > i; j--) if (a[j-1] > a[j]) swap(a, j-1, j); } [ Denne version er “omvendt” i forhold til lærebogsversionen. ]

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

24 Animering af boble-sortering

25 Analyse af boble-sortering Antal sammenligninger: I alle tilfælde: n = n(n-1)/2 = O(n 2 ) Antal ombytninger: Bedste tilfælde: 0 Værste tilfælde: n = n(n-1)/2 = O(n 2 ) Gennemsnitlige tilfælde: cirka n 2 /2 = O(n 2 ) [ svært bevis ]

26 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? Ja, vi kan sortere de delfiler, der fås ved at tage hvert h´te element i den oprindelige fil, hvor h > 1.

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

28 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 4-sortering ved indsættelse Benyt sortering ved indsættelse med “skridtlængde” 4.

29 h-sortering void h_sort(int a[], int n, int h) { for (int i = h+1; i <= n; i++) { int v = a[i]; int j = i; while (j > h && a[j-h] > v) { a[j] = a[j-h]; j -= h; } a[j] = v; } I forhold til insertion er 1 blot erstattet med h, og 2 med h+1.

30 void shellsort(int a[], int n) { int h; for (h = 1; h <= n/9; h = 3*h + 1) ; for ( ; h >= 1; h /= 3) h_sort(a, n, 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.

31 Animering af Shellsort

32 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 ).

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

34 Sortering ved tælling: for (j = 1; j <= M; j++) count[j] = 0; for (i = 1; i <= N; i++) count[a[i]]++; for (j = 2; j <= M; j++) count[j] += count[j-1]; for (i = N; i >= 1; i--) b[count[a[i]]--] = a[i]; for (i = 1; i <= N; i++) a[i] = b[i]; Problem: Sorter en fil af N poster med nøgler, der er heltal mellem 1 og M (begge inklusive), hvor M ikke er for stor. Sortering ved tælling Kompleksitet: O(N)

35 a: A B B A C A D A B B A D D A count[1:4] = 6, 4, 1, 3 count[1:4] = 6, 10, 11, 14 b: A A D A D D A A D D A A B - - D D A A - - B B - - D D A A A - - B B - - D D A A A - - B B - D D D - - A A A A - - B B - D D D - - A A A A - - B B C D D D - A A A A A - - B B C D D D - A A A A A - B B B C D D D - A A A A A B B B B C D D D A A A A A A B B B B C D D D

36 Sortering ved adresseberegning Ide: Antag at der findes en afbildning, map, fra mængden af nøgleværdier over på intervallet [0;N-1], som er ordensbevarende, dvs. k 1 ≤ k 2 map(k 1 ) ≤ map(k 2 ). Vi kan da sortere en fil således: (1) Posterne fordeles i N grupper efter deres map-værdi, idet posterne i hver gruppe ordnes efter deres nøgleværdi. (2) Grupperne gennemløbes i nummerorden, og posterne i hver gruppe udtages i rækkefølge.

37 map(key) = (int) (key/100.0*N) first[0] 3 6 first[1] first[2] first[3] 33 first[4] first[5] first[6] first[7] first[8]. first[9] Omkostning: plads. Metoden er velegnet, hvis map-værdierne fordeler sig jævnt på indeksintervallet [0;N-1]. Det kan være et problem at finde en velegnet map- funktion. Eksempel: Nøgleværdier: heltal  [0;99] N = 10

38 int map(int key, int min, int max, int N) { return (int) 1.0*(key - min)/(max min)*(N+1); } void proxmap(int a[], int N) { int first[] = new int[N], next[] = new int[N+1]; int i, j, k, key, adr, min, max; for (i = 2, min = max = a[1]; i <= N; i++) if ((key = a[i]) < min) min = key; else if (key > max) max = key; for (i = 1; i <= N; i++) { key = a[i]; adr = map(key, min, max, N); j = first[adr]; if (j == 0 || key <= a[j]) { first[adr] = i; next[i] = j; } else { k = next[j]; while (k != 0 && key > a[k]) { j = k; k = next[j]; } next[j] = i; next[i] = k; } int b[] = new int[N+1]; for (adr = 0, i = 0; adr < N; adr++) for (k = first[adr]; k != 0; k = next[k]) b[++i] = a[k]; for (i = 1; i <= N; i++) a[i] = b[i]; }

39 Java (JIT), tid i sekunder: metode N = insertion selection bubble shellsort proxmap Måling af køretider (PowerBook G3, 400 MHz, Metrowerks) C, tid i sekunder: metode N = insertion selection bubble shellsort proxmap

40 Stabile metoder En sorteringsmetode siges at være stabil, hvis den bevarer den relative orden af poster med samme nøgle i filen. 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.

41 Sortering ved indsættelse: void insertion(int a[], int p[], int n) { for (int i = 1; i <= n; i++) p[i] = i; for (int i = 2; i <= n; i++) { int v = p[i], j = i; while (j > 1 && a[p[j-1]] > a[v]) { p[j] = p[j-1]; j--; } p[j] = v; } Ved sammenligning benyttes a[p[j-1]] i stedet for a[j-1]. Ved flytning benyttes p[j] i stedet for a[j]. Hvis posterne er store, kan det ofte betale sig at sortere “pegere” til dem (i stedet for posterne selv). Ekstra omkostning: plads til et array, p, af indices. Sortering af store poster

42 Tilbageføring af poster Før sortering: k a[k] A S O R T I N G E X A M P L E p[k] Efter sortering: k a[k] A S O R T I N G E X A M P L E p[k] Efter permute: k a[k] A A E E G I L M N O P R S T X p[k]

43 void permute(int a[], int p[], int n) { for (int (i = 1; i <= N; i++) if (p[i] != i) { int t = a[i]; int j, k = i; do { j = k; k = p[j]; a[j] = a[k]; p[j] = j; } while (k != i); a[j] = t; } Hver post flyttes kun én gang. Permutering på stedet

44 Forløb for i = 2 i = 2, t = ‘S’ k a[k] A S O R T I N G E X A M P L E p[k] j = 2, k = 11, a[2] = a[11], p[2] = 2 k a[k] A A O R T I N G E X A M P L E p[k] j = 11, k = 13, a[11] = a[13], p[11] = 11 k a[k] A A O R T I N G E X P M P L E p[k] j = 13, k = 2, a[13] = a[2], p[13] = 13, a[13] = t k a[k] A A O R T I N G E X P M S L E p[k]

45 Læs kapitel 9, 11 og 12 i lærebogen (side og side ) Løs følgende opgaver 1. Opgave 8.1, 8.2, 8.3 og På næste side ses et udkast til et Java-program, der opretter en liste af 100 tilfældige positive heltal mellem 1 og 1000 og udskriver listen i sorteret orden. Færdiggør programmet ved at programmere metoden sort. Du kan frit vælge sorteringsmetode, men du må ikke benytte ekstra plads, der afhænger af antallet af elementer. Du må således ikke benytte et array. 3. Opgaven på den derefter følgende side er en god øvelse i algoritmedesign. Den er ikke helt let. Løs den, hvis du har tid og lyst. En løsning vil blive offentliggjort på kursets hjemmeside torsdag den 28. oktober. Ugeseddel 4 7. oktober oktober

46 import java.util.Random; class Node { Node(int k) { key = k; } Node(int k, Node n) { key = k; next = n; } int key; Node next; } public class List { private Node first; public void prepend(int k) { first = new Node(k, first); } public void sort() {... } public void print() { for (Node n = first; n != null; n = n.next) System.out.print(n.key + " "); System.out.println(); } public class Program { public static void main(String arg[]) { List l = new List(); Random r = new Random(); for (int i = 1; i <= 100; i++) l.prepend(Math.abs(r.nextInt())% ); l.sort(); l.print(); }

47