ID1020: Mergesort. Dr. Jim Dowling kap 2.2. Slides adapted from Algoritms 4 th Edition, Sedgewick.

Transkript

1 ID1020: Mergesort Dr. Jim Dowling kap 2.2 Slides adapted from Algoritms 4 th Edition, Sedgewick.

2 Två klassiska algoritmer: mergesort och quicksort Nyckelkomponenter i världens IT-infrastruktur. - Vetenskapliga förståelse av deras egenskaper har möjliggjort deras utveckling i praktiska system. - Quicksort hedrad som en av dem top 10 algoritmer under 1900-talet. Mergesort.... Quicksort.... 2

3 Divide-and-Conquer algoritmer Principen Divide-and-Conquer (dela-och-härska) för algoritmkonstruktion: - Divide: dela upp problemet i mindre, oberoende, delproblem. Delproblem är av samma typ som ursprungsproblemet. Uppdelningen fortsätter sedan tills problemet är nerbrutet i många triviala delproblem. - Conquer: lös delproblemen rekursivt (eller direkt om trivialt). - Resultaten från delproblemen sätts sedan ihop till en lösning av ursprungsproblemet. Tidskomplexitet kan oftast beräknas genom analys av ett rekursionsrelation.

4 Mergesort

5 Mergesort Grundläggande metod. - Dela upp array:n i två halvor. - Sortera rekursivt både halvorna var för sig. - Sammanfoga både halvor. 5

6 Abstract in-place merge demo Mål. Givet två sorterade subarrayer a[lo] till a[mid] och a[mid+1] till a[hi], ersätt med sorterade subarray a[lo] till a[hi]. lo mid mid+1 hi a[] E E G M R A C E R T sorterad sorterad 6

7 Abstract in-place merge demo Mål. Givet två sorterade subarrayer a[lo] till a[mid] och a[mid+1] till a[hi], ersätt med sorterade subarray a[lo] till a[hi]. lo hi a[] A C E E E G M R R T sorterad 7

8 Merging: Java implementation private static void merge(comparable[] a, Comparable[] aux, int lo, int mid, int hi) { for (int k = lo; k <= hi; k++) { aux[k] = a[k]; int i = lo, j = mid+1; for (int k = lo; k <= hi; k++) { if (i > mid) a[k] = aux[j++]; else if (j > hi) a[k] = aux[i++]; else if (less(aux[j], aux[i])) a[k] = aux[j++]; else a[k] = aux[i++]; copy merge aux[] lo i mid j hi A G L O R H I M S T a[] A G H I L M k 9

9 Mergesort: Java implementation public class Merge { private static void merge(...) { /* as before */ private static void sort(comparable[] a, Comparable[] aux, int lo, int hi) { if (hi <= lo) return; int mid = lo + (hi - lo) / 2; sort(a, aux, lo, mid); sort(a, aux, mid+1, hi); merge(a, aux, lo, mid, hi); public static void sort(comparable[] a) { Comparable[] aux = new Comparable[a.length]; sort(a, aux, 0, a.length - 1); lo mid hi

10 Mergesort: trace resultat efter ett rekursivt anrop 13

11 Mergesort: animation 50 i slumpordning algoritm position sorterade nuvarande subarray inte sorterade ännu 14

12 Mergesort: animation 50 omvänd-sorterade poster algoritm position sorterade nuvarande subarray inte sorterade ännu 15

13 Mergesort: empirisk analys Uppskattade körtider: - En laptop exekverar 10 8 jämförelser/sekund. - En superdator exekverar jämförelser/sekund. insertion sort (N 2 ) mergesort (N log N) computer thousand million billion thousand million billion home instant 2.8 hours 317 years instant 1 second 18 min super instant 1 second 1 week instant instant instant Slutsats. Bra algoritmer är bättre än superdatorer. 16

14 Mergesort: antalet jämförelser Sats. Mergesort jämför N lg N för att sortera en array av längd N. Bevis. Antalet jämförelser C (N) för att köra mergesort på en array av längd N satisfierar rekurrensrelationen: C (N) C ( N / 2 ) + C ( N / 2 ) + N där N > 1, med C (1) = 0. vänstra hälften högre hälften sammanfogning (merge) A (N) A( N / 2 ) + A ( N / 2 ) + 6N där N > 1, med A(1) = 0. Vi löser rekurrensrelationen när N är en tvåpotens: D (N) = 2 D (N / 2) + N, för N > 1, med D (1) = 0. Resultat gäller för alla N (men analys är lättare i det här fallet) 17

15 Divide-och-conquer rekurrens: bevis mha bilder Sats. IF D (N) satisfierar D (N) = 2 D (N / 2) + N för N > 1, med D (1) = 0, THEN D (N) = N lg N. Bevis 1. [antar att N är en tvåpotens] D (N) N = N D (N / 2) D (N / 2) 2 (N/2) = N lg N D(N / 4) D(N / 4) D(N / 4) D(N / 4) 4 (N/4) = N D(N / 8) D(N / 8) D(N / 8) D(N / 8) D(N / 8) D(N / 8) D(N / 8) D(N / 8) 8 (N/8) = N T(N) = N lg N 18

16 Divide-och-conquer rekurrens: induktionsbevis Sats. IF D (N) satisfierar D (N) = 2 D (N / 2) + N för N > 1, med D (1) = 0, THEN D (N) = N lg N. Bevis 2. [antar att N är en tvåpotens] - Basfal: N = 1. - Induktionssteget: D (N) = N lg N. - Mål: bevisa att D (2N) = (2N) lg (2N). D (2N) = 2 D (N) + 2N = 2 N lg N + 2N = 2 N (lg (2N) 1) + 2N = 2 N lg (2N) given inductive hypothesis algebra QED 20

17 Mergesort: antal array accesser Sats. Mergesort accesser array:n 6 N lg N gånger för att sortera en array av längd N. Bevis. Antalet array accesser A (N) satisfierar rekurrens-relationen: A (N) A ( N / 2 ) + A ( N / 2 ) + 6 N för N > 1, med A (1) = 0 Viktig punkt. Alla algoritmer med följande struktur tar N log N tid: public static void linearithmic(int N) { if (N == 0) { return; linearithmic(n/2); linearithmic(n/2); linear(n); lös två problem av halva storleken gör en linjär mängd arbete Kända undantag. FFT, m.m., 21

18 Mergesort analys: minneskomplexitet Sats. Mergesort använder extra minne proportionellt mot N. Bevis. The array aux[] needs to be of length N for the last merge. två sorterade subarrayer A C D G H I M N U V A B C D E F G H I J B E F J O P Q R S T M N O P Q R S T U V merged result Def. En sorteringsalgoritm är in-place om den använder c log N extra minne. T.ex. Insertion sort, selection sort, shellsort. Utmaning 1 (inte svårt). Använd aux[] array av längd ~ ½ N istället för N. Utmaning 2 (jätte svårt). In-place merge. [Kronrod 1969] 22

19 Mergesort: förbättringar Använd insertion sort för små subarrayer. - Mergesort har för mycket overhead för mycket små subarrayer. - Brytpunkt (cutoff) under 10 poster använd insertion sort. private static void sort(comparable[] a, Comparable[] aux, int lo, int hi){ if (hi <= lo + CUTOFF - 1) { Insertion.sort(a, lo, hi); return; int mid = lo + (hi - lo) / 2; sort (a, aux, lo, mid); sort (a, aux, mid+1, hi); merge(a, aux, lo, mid, hi); 23

20 Mergesort brytpunkt till insertion sort: visualisering 24

21 Mergesort: förbättringar Sluta om redan sorterad. - Om största posten i första hälften minsta posten i andra hälften? - Det hjälper för delvis ordnande arrayer. A B C D E F G H I J A B C D E F G H I J M N O P Q R S T U V M N O P Q R S T U V private static void sort(comparable[] a, Comparable[] aux, int lo, int hi) { if (hi <= lo) return; int mid = lo + (hi - lo) / 2; sort (a, aux, lo, mid); sort (a, aux, mid+1, hi); if (!less(a[mid+1], a[mid])) return; merge(a, aux, lo, mid, hi); 25

22 Mergesort: förbättringar Eliminera kopiering till auxiliary array:n. Spara tid (men inte minne) genom att byta rollen av input och auxiliary array:n under varje rekursivanrop. private static void merge(comparable[] a, Comparable[] aux, int lo, int mid, int hi) { int i = lo, j = mid+1; for (int k = lo; k <= hi; k++) { if (i > mid) aux[k] = a[j++]; else if (j > hi) aux[k] = a[i++]; else if (less(a[j], a[i])) aux[k] = a[j++]; else aux[k] = a[i++]; private static void sort(comparable[] a, Comparable[] aux, int lo, int hi) { if (hi <= lo) return; int mid = lo + (hi - lo) / 2; sort (aux, a, lo, mid); sort (aux, a, mid+1, hi); merge(a, aux, lo, mid, hi); switch roles of aux[] och a[] assumes aux[] is initialized to a[] once, before recursive calls merge from a[] to aux[] 26

23 Java 6 systemsort Grundläggande algoritm för sortering av objekt = mergesort. - Brytpunkten (cutoff) till insertion sort = 7. - Sluta om redan sorterad test. - Eliminera kopiering till auxillary array knep. Arrays.sort(a) 27

24 Bottom-up Mergesort

25 Bottom-up mergesort Grundläggande metod. - Pass-through array, samanfogar subarrayer av storlek 1. - Upprepa för subarrayer av storlek 2, 4, 8,... 29

26 Bottom-up mergesort: Java implementation public class MergeBU { private static void merge(...) { /* as before */ public static void sort(comparable[] a) { int N = a.length; Comparable[] aux = new Comparable[N]; for (int sz = 1; sz < N; sz = sz+sz) for (int lo = 0; lo < N-sz; lo += sz+sz) merge(a, aux, lo, lo+sz-1, Math.min(lo+sz+sz-1, N-1)); ungefär 10% långsammare än rekursiv, top-down mergesort på vanliga system Slutsats. Enkel och icke-rekursiv version av mergesort. 30

27 Mergesort: visualisering top-down mergesort (cutoff = 12) bottom-up mergesort (cutoff = 12) 31

28 Tidskomplexitet av mergesort

29 Tidskomplexitet för sortering Kostnadsmodell. Antal operationer. Övre gräns. Kostnadsgaranti av någon algoritm för X. Lägre gräns. Ingen algoritm för X har en kostnad lägre än gränsen. Optimal algoritm. Algoritm med bäst möjliga kostnadsgaranti för X. lägre gräns ~ övre gräns Exempel: sortering. - beräkningsmodellen: beslutsträd. - kostnadsmodell: # jämförelser. - Övre gräns: ~ N lg N från mergesort. - Lägre gräns :? - Optimal algoritm:? kan bara accessa information genom jämförelser (t.ex., Java Comparable framework) 33

30 Beslutsträd (för 3 unika nycklar a, b, och c) yes a < b kod mellan jämförelser (t.ex, sekvens av utbyte) no djupet av trädet = worst-case antal jämförelser b < c a < c yes no yes no a b c a < c b a c b < c yes no yes no a c b c a b b c a c b a varje löv motsvarar en (och bara en) ordning, minst en löv för varje möjliga ordning. 34

31 Jämförelese-baserad lägre gräns för sortering Sats. Alla jämför-baserade sorteringsalgoritmer måste jämföra minst lg ( N! ) ~ N lg N gånger i worst-case (värsta fall). Bevis. - Vi antar att array:n bestå av N unika värde a1 till an. - Worst case bestämmas av djupet (height) h av beslutsträdet. - Binärträdet av djupet h har som mest 2 h löv. - N! olika ordningar minst N! löv. 35

32 Jämförelse-baserade lägre gräns för sortering Sats. Alla jämförelse-baserade sorteringsalgoritmer måste jämföra minst lg ( N! ) ~ N lg N gånger i worst-case. Bevis. - Vi antar att array:n bestå av N unika värde a1 till an. - Worst case bestämmas av djupet (height) h av beslutsträdet. - Binärträdet av djupet h har som mest 2 h löv. - N! olika ordningar minst N! löv. 2 h # löv N! h lg ( N! ) ~ N lg N Stirlings formel 36

33 Tidskomplexitet för sortering Kostnadsmodell. Antal operationer. Övre gräns. Kostnadsgaranti av någon algoritm för X. Lägre gräns. Ingen algoritm för X har en kostnad lägre än gränsen. Optimal algoritm. Algoritm med bäst möjliga kostnadsgaranti för X. Exempel: sortering. - beräkningsmodellen: beslutsträd. - kostnadsmodell: # jämförelser. - Övre gräns: ~ N lg N från mergesort. - Lägre gräns : ~ N lg N. - Optimal algoritm = mergesort. Första mål av algoritm design: optimal algoritms. 37

34 Komplexitet resulterar i kontext Jämförelser? Mergesort är optimalt med avseende på antal jämförelser. Space? Mergesort är inte optimalt med avseende på hur mycket minnet den använder (minneskomplexitet). Läxan. Teori hjälper oss hitta bättre lösningar. T.ex. Kan man designa en sorteringsalgoritm som garanterar ½ N lg N jämförelser? T.ex. Kan man designa en sorteringsalgoritm som är optimalt, med avseende på både tid- och minnes-komplexitet? 38

35 Beräkningskomplexit resultaten i kontext (fort.) Lägre gräns kan sänkas vidare om algoritmen kan utnyttja: - Första ordningen av input (indatan). T.ex.: insertion sort behöver bara ett linjärt antal jämförelser på delvis sorterade arrayer. - Distributionen av värden av nycklarna. T.ex. : 3-way quicksort behöver bara ett linjär antal jämförelser på arrayer när antalet unika nycklar är konstant. [nästa föreläsningen] - Representationen av nycklarna. T.ex. : radix sort behöver inga nyckeljämförelser den accessar data med hjälp av karaktär/tal jämförelser. 39

36 Mergesort komparatorer

37 Sortera länder efter guldmedaljer

38 Sortera länder efter totalt antal medaljer

39 Sortera ett musikbibliotek efter artistnamn

40 Sortera ett musikbibliotek efter låtnamn

41 Comparable interface: repris Comparable interface: sortera med natural order av en typ. public class Date implements Comparable<Date> { private final int month, day, year; public Date(int m, int d, int y) { month = m; day = d; year = y; public int compareto(date that) { if (this.year < that.year ) return -1; if (this.year > that.year ) return +1; if (this.month < that.month) return -1; if (this.month > that.month) return +1; if (this.day < that.day ) return -1; if (this.day > that.day ) return +1; return 0; natural order 47

42 Comparator interface Comparator interface: sortera med en alternativ ordning. public interface Comparator<Key> int compare(key v, Key w) jämför nycklar v och w Krav. Måste definiera en totalordning. string order Exempel natural order case insensitive Now is the time is Now the time pre-1994 order for digraphs ch och ll och rr Spanish language café cafetero cuarto churro nube ñoño British phone book McKinley Mackintosh 48

43 Frikoppla (decouple) comparator interface från datatypen Använd med Java system sort: - Skapa ett Comparator objekt. - Skicka som andra argument till Arrays.sort(). använder en alternativ ordning definierade String[] a; uses natural order av Comparator<String> objekt... Arrays.sort(a);... Arrays.sort(a, String.CASE_INSENSITIVE_ORDER);... Arrays.sort(a, Collator.getInstance(new Locale("es")));... Arrays.sort(a, new BritishPhoneBookOrder());... Slutsats. Frikoppla definitionen av datatypen från definitionen av vad det betyder att jämföra objekt av samma typ. 49

44 Comparator interface: att använda sorteringsbibliotek från boken För att använda comparators i bokens sorteringsimplementationer: - Använd Object istället för Comparable. - Skicka Comparator till sort() och less() och använd den i less(). insertion sort med en Comparator public static void sort(object[] a, Comparator comparator) { int N = a.length; for (int i = 0; i < N; i++) for (int j = i; j > 0 && less(comparator, a[j], a[j-1]); j--) exch(a, j, j-1); private static boolean less(comparator c, Object v, Object w) { return c.compare(v, w) < 0; private static void exch(object[] a, int i, int j){ Object swap = a[i]; a[i] = a[j]; a[j] = swap; 50

45 Att implementera en Comparator interface Att implementera en comparator: - Definiera en (nested) klass som implementerar Comparator interface:n. - Implementera compare() metoden. public class Student { private final String name; private final int section;... public static class ByName implements Comparator<Student> { public int compare(student v, Student w) { return v.name.compareto(w.name); public static class BySection implements Comparator<Student> { public int compare(student v, Student w) { return v.section - w.section; 51

46 Att implementera en Comparator interface Att implementera en comparator: - Definiera en (nested) klass som implementerar Comparator interface:n. - Implementera compare() metoden. Arrays.sort(a, new Student.ByName()); Arrays.sort(a, new Student.BySection()); Andrews 3 A Little Battle 4 C Whitman Chen 3 A Blair Fox 3 A Dickinson Furia 1 A Brown Gazsi 4 B Brown Kanaga 3 B Brown Rohde 2 A Forbes Furia 1 A Brown Rohde 2 A Forbes Andrews 3 A Little Chen 3 A Blair Fox 3 A Dickinson Kanaga 3 B Brown Battle 4 C Whitman Gazsi 4 B Brown 52

47 Att implementera en Comparator interface Att implementera en comparator: - Definiera en (nested) klass som implementerar Comparator interface:n. - Implementera compare() metoden. public class Student { public static final Comparator<Student> BY_NAME = new ByName(); public static final Comparator<Student> BY_SECTION = new BySection(); private final String name; private final int section;... public static class ByName implements Comparator<Student> { public int compare(student v, Student w) { return v.name.compareto(w.name); public static class BySection implements Comparator<Student> { public int compare(student v, Student w) { return v.section - w.section; 53

48 Mergesort stabilitet

49 Stabilitet En vanlig applikation. Först, sortera efter namn; sedan sortera efter Section. Selection.sort(a, new Student.ByName()); Selection.sort(a, new Student.BySection()); Andrews 3 A Little Battle 4 C Whitman Chen 3 A Blair Fox 3 A Dickinson Furia 1 A Brown Gazsi 4 B Brown Kanaga 3 B Brown Rohde 2 A Forbes Furia 1 A Brown Rohde 2 A Forbes Chen 3 A Blair Fox 3 A Dickinson Andrews 3 A Little Kanaga 3 B Brown Gazsi 4 B Brown Battle 4 C Studenter i section 3 inte längre sorterad efter namn. En stabil sortering behåller den relativa ordningen av poster med samma nycklar.

50 Stabilitet Vilka sorteringsalgoritmer är stabila? Vi behöver kontrollera algoritmen (och implementationen) för att se om den är stabil eller inte. 57

51 Stabilitet: insertion sort Sats. Insertion sort är stabil. public class Insertion { public static void sort(comparable[] a) { int N = a.length; for (int i = 0; i < N; i++) for (int j = i; j > 0 && less(a[j], a[j-1]); j--) exch(a, j, j-1); i j B1 A1 A2 A3 B2 Bevis. Om två poster är lika, insertion sort aldrig flyttar en av posterna förbi den andra. 1 0 A1 B1 A2 A3 B2 2 1 A1 A2 B1 A3 B2 3 2 A1 A2 A3 B1 B2 4 4 A1 A2 A3 B1 B2 A1 A2 A3 B1 B2 58

52 Stabilitet: selection sort Sats. Selection sort är inte stabil. public class Selection { public static void sort(comparable[] a) { int N = a.length; for (int i = 0; i < N; i++) { int min = i; for (int j = i+1; j < N; j++) if (less(a[j], a[min])) min = j; exch(a, i, min); i min B1 B2 A 1 1 A B2 B1 2 2 A B2 B1 A B2 B1 Bevis genom motexempel. Lång-avstånd swapping kan flytta en post förbi en annan med samma värde. 59

53 Stabilitet: shellsort Sats. Shellsort sort är inte stabil. public class Shell { public static void sort(comparable[] a) { int N = a.length; int h = 1; while (h < N/3) h = 3*h + 1; while (h >= 1) { for (int i = h; i < N; i++) { for (int j = i; j > h && less(a[j], a[j-h]); j -= h) exch(a, j, j-h); h = h/3; h B1 B2 B3 B4 A1 4 A1 B2 B3 B4 B1 1 A1 B2 B3 B4 B1 A1 B2 B3 B4 B1 Bevis genom motexempel. Lång-avstånd swapping kan flytta en post förbi en annan med samma värde. 60

54 Stabilitet: mergesort Sats. Mergesort är stabil. public class Merge { private static void merge(...) { /* as before */ private static void sort(comparable[] a, Comparable[] aux, int lo, int hi) { if (hi <= lo) return; int mid = lo + (hi - lo) / 2; sort(a, aux, lo, mid); sort(a, aux, mid+1, hi); merge(a, aux, lo, mid, hi); public static void sort(comparable[] a) { /* as before */ Bevis. Det räcker att verifiera att sammanfogning-operationen är stabil. 61

55 Stabilitet: mergesort Sats. Sammanfogning operationen är stabil. private static void merge(...) { for (int k = lo; k <= hi; k++) aux[k] = a[k]; int i = lo, j = mid+1; for (int k = lo; k <= hi; k++) { if (i > mid) a[k] = aux[j++]; else if (j > hi) a[k] = aux[i++]; else if (less(aux[j], aux[i])) a[k] = aux[j++]; else a[k] = aux[i++]; A1 A2 A3 B D A4 A5 C E F G Bevis. Tar från vänstra subarray:n om nycklarna är lika. 62

56 Sortering sammanfattning inplace? stable? best average worst remarks selection ½ N 2 ½ N 2 ½ N 2 N exchanges insertion N ¼ N 2 ½ N 2 use for small N or partially ordered shell N log3 N? c N 3/2 tight code; subquadratic mergesort ½ N lg N N lg N N lg N N log N guarantee; stable? N N lg N N lg N holy sorting grail 63