Sortieren und Suchen. Hallo Welt Seminar Jochen Gierling

Transkript

1 Sortieren und Suchen Hallo Welt Seminar 2008 Jochen Gierling

2 Übersicht I II III IV V Problem des Sortierens und Suchens, Anwendungen und Motivation Sortieralgorithmen Suchalgorithmen Range Minimum Query Bibliotheksfunktionen (Java, C, C++) 2

3 Sortier- & Such-Problem Suchproblem Finde ein bestimmtes Element in einer Menge Verwandtschaft Sortierproblem sortiere eine Menge der Größe nach In einer sortierten Menge ist das Suchen einfacher! I Problem des Sortierens und Suchens, Anwendungen und Motivation 3

4 Beispiele für Anwendungen Eindeutigkeitstests/Häufigkeitstests Statistiken (Mittelwert, Auswahl) Suchen als Hilfsmittel zum Sortieren Operationen auf Mengen (z.b. Vereinigung, Schnitt) Finden von Paaren (Matching) I Problem des Sortierens und Suchens, Anwendungen und Motivation 4

5 Computer manufacturers in the 1960s estimated that more than 25 percent of the running time of computers were spent sorting. [ ] In fact, there were many installations in which tasks of sorting were responsible für more than half of the computing time. (Donald E. Knuth) I Problem des Sortierens und Suchens, Anwendungen und Motivation 5

6 Anspruch an (Sortier-)verfahren wenig Vergleiche wenig Zuweisungen wenig Speicherplatz d.h. minimaler Aufwand I Problem des Sortierens und Suchens, Anwendungen und Motivation 6

7 Insertionsort (Idee) Aufteilung in sortierten und unsortierten Bereich Nimm beliebiges Element aus dem unsortierten Bereich und füge es an der richtigen Stelle in den sortierten Bereich ein Sortierter Bereich wächst an, unsortierter nimmt ab. 7

8 Insertionsort (Codebeispiel) int i, j; for(i=1; i<n; i++) { j=i; while((j>0)&&(s[j] < s[j-1])) { swap(&s[j], &s[j-1]); j=j-1; Sortierter Bereich (Länge i)

9 Insertionsort Aufwand O(n²) (fast) kein zusätzlicher Speicherplatz notwendig 9

10 Mergesort (Idee) Aufteilen der Menge in 2 (etwa) gleichgroße Teile Die 2 Teile sortieren (wieder durch Aufteilung in 2 Teile, wobei einelementige Mengen sortiert sind) Dann Mergen ( Mischen ), d.h. zusammenführen mit vergleichendem Reißverschlussverfahren 10

11 Mergesort (Beispiel) Teilen Teilen Teilen Teilen Mergen Mergen Mergen Mergen 11

12 Mergesort Aufwand O(n log(n)) Sowohl rekursiv, wie auch iterativ implementierbar Braucht allerdings doppelt so viel Speicher wie das zu sortierende Array 12

13 Mergesort (rekursiv) void mergesort_rec(int a[], int b[], int l, int r) { int m; if(r > l) { m = (r + l) / 2; mergesort_rec(a, b, l, m); // linke Seite mergesort_rec(a, b, m + 1, r);// rechte Seite merge(a, b, l, r); 13

14 Mergesort (rekursiv) void merge(int a[], int b[], int l, int m, int r) { int i, j, k; for(i=1; i<m+1; ++i) b[i] = a[i]; // in Hilfsarray for(j=m; j<r; ++j) b[r+m-j] = a[j+1]; i = 1; j = m; for(k=1; k<=r; ++k) { // eigentliches Mergen if(b[i] < b[j]) a[k] = b[i++]; else a[k] = b[j++]; 14

15 Mergesort (iterativ) Für k = 1, 2, immer zwei disjunkte Teilarrays der Länge 2 k (der letzte darf kleiner sein) zusammenmischen. (verwendet auch Hilfsarray) Iteration k = k = k =

16 Mergesort (iterativ) void mergesort_iter(int a[], int b[], int len) { int w, i; for(w=1; w<len; w*=2) { for(i=0; i<len; i+=2*w) { int l = i; int m = min(len, i + w); int r = min(len, i + 2*w); merge(a, b, l, m-1, r-1); 16

17 Heapsort (Idee) Basiert auf Heap-Datenstruktur (fast vollständiger Binärbaum Pro Knoten ein Datensatz Nummeriere die Knoten von oben nach unten, von links nach rechts 17

18 Heapsort (Idee) Wurzel Blatt Blatt Blatt Blatt Blatt Speichern in Array: a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 18

19 Heapsort (Idee) Knoten i, dann ist: linkes Kind: 2i + 1 rechtes Kind: 2i+2 Vater: floor[(i-1) / 2] Blätter sind Knoten ohne Kinder, d.h. 2i+1 > n-1 Heapeigenschaft: Vater > beide Kinder Erfüllt, wenn a[i] > a[2i+1] und a[i] > a[2i+2] für alle Knoten die keine Blätter sind 19

20 Heapsort (Algorithmus) 1) Schreibe die Datensätze beliebig in den Heap 2) Stelle Heapeigenschaft her O(n log(n)) So lange noch Elemente im Heap (d.h. n mal): 3) Entferne das Wurzelelement (größtes Element) und ersetze es durch das Blatt in der untersten Ebene, das am weitesten rechts ist O(1) 4) Stelle Heapeigenschaft her O(log(n)) 20

21 Heapsort (Heapeigenschaft nach Wurzelentfernung) Nach dem Ersetzen der Wurzel durch das Blatt am weitesten rechts Fange bei der Wurzel an, überprüfe ob Knoten größer als Kinder, wenn nicht tauschen. Falls getauscht wird, muss der neue Kindknoten auf größer als Kinder geprüft werden, eventuell wieder tauschen (Aufwand O(log(n))) 21

22 Heapsort (Heapeigenschaft nach Wurzelentfernung) entfernen Heapeigenschaft! 22

23 Heapsort (Heapeigenschaft am Anfang) Am Anfang: total unsortierter Baum Gehe den Baum von rechts unten nach links, dann nach oben ab (entspricht den Array von rechts nach links durchgehen). Zu jedem Knoten überprüfe ob der Teilbaum unter ihm ein Heap ist. Gehe dabei so vor wie wenn der Knoten eine neue Wurzel wäre (vgl. Herstellung der Heapeigenschaft nach Wurzelentfernung.) 23

24 Heapsort (Codebeispiel) void heapsort(int a[], int len) { int i, l; for(i=len; i>=0; i--) // Heapeigenschaft reheap(a, len, i); for(l=len-1; l>=1; l--) // swap(&a[0], &a[l]) // Wurzel entfernen reheap(a, len, i); // Heapeigenschaft 24

25 Heapsort (Codebeispiel) void reheap(int a[], int len, int r) { int i = r; int j = 2*r + 1; while(j < len) { if((j + 1 < len) && (a[j + 1] > a[j])) j++; // Vergleich Vater/Kind if(a[j] > a[i]) { swap(&a[i], &a[j]); i = j; j = 2*j + 1; else break; 25

26 Heapsort Aufwand O(n log(n)) Kein zusätzliches Speicherarray wie bei Mergesort Allerdings: Allerdings Heap konzeptionell aufwändiger zu implementieren 26

27 Bucketsort Den Elementen liegt ein Ordnungsprinzip zugrunde, so dass sie in Gruppen und diese Gruppen (und evtl. Untergruppen) wieder nach dem selben Prinzip in Untergruppen zerlegbar sind, so dass für beliebige Elemente g 1, g 2, g n aus den Gruppen G 1, G 2, G n gilt: g 1 < g 2 < < g n Ein Eimer ( Bucket ) pro Gruppe. Elemente in einen Eimer rein. (1. Gruppierung) Elemente jedes Eimers in einen Untereimer (2. Gruppierung) 27

28 Bucketsort (Beispiel) Zahlen sortieren 91, 56, 36, 55, 59 Gruppierung: 10 Buckets, im i-ten Schritt nach der i-ten Ziffer ordnen (i = 1, 2)

29 Bucketsort (Pseudocode) bucketsort(list a, j) { if(j == number_of_keys) return a; // unterste Ebene, nix tun new list bucket[number_of_buckets]; new list b; for(k = 0; k < length(liste); k++) { // in Eimer schmeißen b = a[k].key[j]%k; bucket[b].add(a[k]); for(k=0; k < number_of_buckets; k++) { //Eimer erneut sortieren bucketsort(bucket[k], j+1); for(k=0; k < number_of_buckets; k++) { // Eimer leeren b.add(bucket[k]); return b; 29

30 Bucketsort Aufwand O(n + N) bei n Elementen, N Eimern Benötigt zusätzlichen Speicher für die Eimer Wenn nur noch wenige Elemente in den Buckets sind (Größenordnung 10er-Bereich), dann schaltet man auf einfachen Algorithmus, etwa Bubbeln um, wegen des Overheads durch die Rekursion. Klassische Anwendung: Postleitzahlen 30

31 Quicksort (Idee) Wähle Pivotelement p beliebig Teile in zwei Teile (größer bzw. kleiner p) <p p >p rekursiv fortfahren <s s >s p <q q >q Mögliche Durchführung: - Pivotelement ist immer ganz rechts - Suche von links mit Zeiger i Elemente größer als p, von rechts Elemente kleiner p mit Zeiger j - Vertausche die gefundenen Elemente, Abbruch bei i j 31

32 Quicksort (Codebeispiel) void quicksort(int a[], int l, int r) { int p; if(l < r) { p = partition(a, l, r); quicksort(a, 1, p - 1); quicksort(a, p + 1, r); Beispiel: int partition(int a[], int l, int r) { int i = l-1, j = r; int p = r; while(i < j) { do i++; while((i<j) && (a[i] < a[p])); do j--; while((j>i) && (a[j] > a[p])); if(i >= j) swap(&a[i], &a[p]); else swap(&a[i], &a[j]); return(i); 32

33 Quicksort (Codebeispiel) void quicksort(int a[], int l, int r) { int p; if(l < r) { p = partition(a, l, r); quicksort(a, 1, p - 1); quicksort(a, p + 1, r); int partition(int a[], int l, int r) { int i = l-1, j = r; int p = r; while(i < j) { do i++; while((i<j) && (a[i] < a[p])); do j--; while((j>i) && (a[j] > a[p])); if(i >= j) swap(&a[i], &a[p]); else swap(&a[i], &a[j]); return(i); p Beispiel: i = j nix zu tun 33

34 Quicksort (Codebeispiel) void quicksort(int a[], int l, int r) { int p; if(l < r) { p = partition(a, l, r); quicksort(a, 1, p - 1); quicksort(a, p + 1, r); p i j int partition(int a[], int l, int r) { int i = l-1, j = r; int p = r; while(i < j) { do i++; while((i<j) && (a[i] < a[p])); do j--; while((j>i) && (a[j] > a[p])); if(i >= j) swap(&a[i], &a[p]); else swap(&a[i], &a[j]); return(i); j i

35 Quicksort (Aufwand) Aufwand worst case: O(n²) likely case O(n log(n)) d.h. trotz des O(n²)-Aufwands im worst case ist Quicksort in den meisten Fällen O(n log(n)) Verbesserung Wähle (zufällig) mehrere Elemente (etwa 3) aus und nimm das Mittlere. (denn Pivotelement sollte möglichst mittig liegen) 35

36 Zusammenfassung (Sortieren) worst case likely case best case Insertionsort O(n²) O(n²) O(n) Mergesort O(n log(n)) O(n log(n)) O(n log(n)) Heapsort O(n log(n)) O(n log(n)) O(n log(n)) Bucketsort O(n+m) O(n+m) O(n+m) Quicksort O(n²) O(n log(n)) O(n log(n)) Bubblesort O(n²) O(n²) O(n) Selectionsort O(n²) O(n²) O(n²) 36

37 Lineare Suche simpelster intuitiver Suchalgorithmus bei unsortierter Liste: gehe Liste von Anfang bis Ende durch O(n) int linearesuche(int a[], int len, int x) { int i; for(i=0; i<len; i++) if(a[i] == x) return i; return -1; III Suchalgorithmen 37

38 Binäre Suche Benötigt sortierte Liste Vergleich mit mittlerem Listenelement weitersuchen in linker bzw. rechter Teilliste O(log n) int binaeresuche(int a[], int l, int r, int x) { int m = (l + r)/2; if(l < r && x!= a[m]) if(x < a[m]) return binaeresuche(a, l, m-1, x); else return binaeresuche(a, m+1, r, x); else return (x==a[m]); III Suchalgorithmen 38

39 Quickselect Hier sucht man nicht ein bestimmtes Element, sondern ein Element mit bestimmtem Rang, d.h. man sucht das k-kleinste Element der Liste. Angelehnt an Quicksort: Bestimme Pivotelement p, teile wie bei Quicksort auf. Das ergibt Rang von p, falls k < Rang p suche in linker Teilliste, falls k > Rang p suche in rechter (rekursiv) Likely case: O(n), weil im Gegensatz zu Quicksort nur eine Teilliste expandiert werden muss III Suchalgorithmen 39

40 Zusammenfassung (Suchen) Aufwand Sucht Voraussetzungen Lineare Suche O(n) beliebiges Element Binäre Suche O(log(n)) beliebiges Element Sortierte Liste Quickselect O(n) Element mit bestimmtem Rang III Suchalgorithmen 40

41 RMQ (Problem) Gegeben: Gesucht: Array A[], Länge N Matrix RMQ A (bzw. Teile davon) wobei RMQ A (i,j) die Position des kleinsten Elements unter A[i], A[i+1],, A[j] ist. RMQ A (3,6) = 4 A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] IV Range Minimum Query 41

42 RMQ (1. Lösung) Brute force Methode: Lineare Suche für jedes Paar i, j O(n³) Kann mit dynamischer Programmierung einfach auf O(n²) runtergebrochen werden. void trival(int M[][], int A[], int N) { int i, j; for(i =0; i < N; i++) M[i][i] = i; for (i = 0; i < N; i++) for (j = i + 1; j < N; j++) if (A[M[i][j - 1]] < A[j]) M[i][j] = M[i][j - 1]; else M[i][j] = j; IV Range Minimum Query 42

43 RMQ (2. Lösung) Wurzel(N)-Partitionierung: Teile A in sqrt(n) große Teile und berechne deren Minimum. Aufwand O(n). Zur Berechnung von von RMQ A (i,j) bestimmt man dann das Minumum als maximal 3 sqrt(n) Werten. Aufwand O(sqrt(N)). RMQ A (2,6) = 4 A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] M[0] = 0 M[1] = 4 M[2] = 6 M[3] = 9 IV Range Minimum Query 43

44 RMQ (3. Lösung) Noch besser: Vorarbeit: Bestimme RMQ für alle Unterarrays der Länge 2 k. Verwende dynamische Programmierung. Das ganze im Array M[0, N-1][0, logn] speichern, wobei M[i][j] das Minimum des Array von i bis i+2 j -1 ist. Aufwand O(n log(n)) Auswertung: Wähle zwei Blöcke, die das beliebige Intervall [i, j] überdecken und finde deren Minimum. Aufwand O(1) RMQ A (1,7) = 5 A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] M[2,2] M[4,2] IV Range Minimum Query 44

45 C void qsort ( void *bsearch ( Auch: lsearch( ) hsearch( ) void * base, size_t num, size_t size, int ( * comparator ) ( const void *, const void * )); const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)); benötigen stdlib.h bzw. search.h V Bibliotheksfunktionen (Java, C, C++) 45

46 C Beispiel qsort() #include <stdio.h> #include <stdlib.h> int values[] = { 17, 55, 90, 20, 25 ; int compare (const void * a, const void * b) { return ( *(int*)a - *(int*)b ); int main () { int n; qsort (values, 5, sizeof(int), compare); for (n=0; n<6; n++) printf ("%d ",values[n]); return 0; V Bibliotheksfunktionen (Java, C, C++) 46

47 Java java.util.arrays static int binarysearch(byte[] a, byte key) static void sort(byte[] a) java.util.collection (List<E>, Set<E>) boolean contains(object o) V Bibliotheksfunktionen (Java, C, C++) 47

48 C++ template <class RandomAccessIterator,> void sort( RandomAccessIterator first, RandomAccessIterator last); partial_sort( RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last); template <class RandomAccessIterator, class Compare> void sort( RandomAccessIterator first, RandomAccessIterator last, Compare comp); (auch jeweils stable_sort( )) V Bibliotheksfunktionen (Java, C, C++) 48

49 C++ template <class RandomAccessIterator> void nth_element( RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last); template <class ForwardIterator, class T> bool binary_search( ForwardIterator first, ForwardIterator last, const T& value); Weitere Bibliotheksfunktion: lower/upper_bound(), equal_range() merge() V Bibliotheksfunktionen (Java, C, C++) 49

50 Literatur C++ Einführung und professionelle Programmierung, Ulrich Breymann, ISBN Introduction To Algorithms (second edition), Cormen, Leiserson, Rivest, Stein, ISBN monancestor#range_minimum_query_(rmq) 50