Suchen und Sortieren

Transkript

1 Suchen und Sortieren Suchen Sortieren Mischen Zeitmessungen Bewertung von Sortier-Verfahren Seite 1 Suchverfahren Begriffe Suchen = Bestimmen der Position (Adresse) eines Wertes in einer Datenfolge Sequentielles Suchen einfachstes Suchverfahren keine Vorbedingungen (Ordnung) notwendig hoher Suchaufwand: im Durchschnitt n/2 Zugriffe für eine n-elementige Datenmenge Seite 2

2 Suchverfahren Binäre Suche Voraussetzung: sortierte Folge Algorithmus: 1. Anfangsindex first=1; Anzahl der Werte n 2. Test des Wertes "in der Mitte" der Folge, also bei Position m = (first + n/2) 3. Ist das der gesuchte Wert: Ende 4. Ist der gesuchte Wert größer, dann Ausschluss des Bereiches von Position first bis (first + n/2): first = first + n/2; n=(n+1)/2 sonst Ausschluss des Bereiches von Position (first + n/2) bis n: n=(n+1)/2 5. Wiederhole ab Schritt 2. Seite 3 Suchverfahren Binäre Suche Beispiel: gesucht 45 in der vorliegenden Folge Zugriff 4. Zugriff: gefunden 3. Zugriff 1. Zugriff Seite 4

3 Suchverfahren Fibonacci-Suche Voraussetzung: sortierte Folge Algorithmus: analog Binäres Suchen, jedoch Teilung nicht in zwei gleich große Bereiche, sondern nach dem "Goldenen Schnitt", entspr. der Fibonacci-Zahlen (1, 2, 3, 5, 8, 13, 21, 34, 55, 89,...) Beispiel: gesucht 45 in der vorliegenden Folge Zugriff: gefunden 2. Zugriff 1. Zugriff Seite 5 Suchverfahren Interpolationssuche Voraussetzung: sortierte Folge Algorithmus: analog Binäres Suchen, jedoch Teilung nicht in zwei gleich große Bereiche, sondern gewichtete Positionierung des nächsten Vergleichs bei m, berechnet über den Minimalwert (l) und Maximalwert (r) im noch zu untersuchenden Bereich key k[l] m = l + * (r l) 45 7 k[r] k[l] m 1 = 1+ * (15-1) = Beispiel: gesucht 45 in der vorliegenden Folge Zugriff 2. Zugriff: gefunden Seite 6

4 Daten sortieren verschiedene SelectionSort BubbleSort Seite 7 SelectionSort Seite 8

5 SelectionSort Algorithmus für Sortierung in aufsteigender Folge: 1. Setze den Anfangszeiger auf das 1. Element der unsortierten Folge (=Suchfolge). 2. Durchsuche die Folge vom aktuellen Anfangszeiger bis zum Ende nach dem kleinsten Element und merke Dir dessen Position und Wert. 3. Vertausche das jeweils 1. Element der Suchfolge mit dem kleinsten; dieses steht damit in der sortierten Folge an der "richtigen Stelle". 4. Setze den Anfangszeiger um eine Position weiter, auf das nunmehr 1. Element der verbleibenden, unsortierten Folge. 5. Wiederhole die Schritte 2. bis 5. solange, bis der Anfangszeiger auf das vorletzte Element zeigt; die Folge ist dann sortiert. Seite 9 SelectionSort void SelectionSort (int arr[], long int anz) { int min; long int h, k, pos; for (h=0; h<anz-1; h++) { min = arr[h]; pos = h; for (k=h+1; k<anz; k++) { if (arr[k] < min) { min = arr[k]; pos = k; arr[pos] = arr[h]; arr[h] = min; Seite 10

6 BubbleSort Seite 11 BubbleSort Seite 12

7 BubbleSort Algorithmus für Sortierung in aufsteigender Folge: 1. Setze den Anfangszeiger auf das 1. Element der unsortierten Folge (=Suchfolge). 2. Setze die "Tauschkennung" auf Vergleiche das 1. und das 2. Element der Folge. 4. Falls das (jeweils) 2. kleiner ist als das (jeweils) 1., vertausche beide miteinander und erhöhe die "Tauschkennung". 5. Wiederhole Schritt 3. und 4. für alle Elementpaare der Suchfolge. 6. Das größte Element der Suchfolge befindet sich nun an deren Ende. Verkürze die Suchfolge am Ende um Wiederhole die Schritte 1. bis 6., solange die "Tauschkennung" nach Durchlaufen der Schritte 3. bis 6. größer 0 ist oder aber (n-1) Durchläufe erreicht sind. Verbessungsmöglichkeit: abwechselnd von vorn und von hinten beginnen Seite 13 BubbleSort void BubbleSort (int arr[], long int anz) { int tausch, hilf; long int k; do { tausch = 0; for (k=0; k<anz-1; k++) { if (arr[k+1] < arr[k]) { hilf = arr[k]; arr[k] = arr[k+1]; arr[k+1] = hilf; tausch++; anz--; while (tausch); Seite 14

8 Vergleich der Animation: E:\modul_04_cd\Lektion_do06\text\Java\sortAlgorithms.html Seite 15 QuickSort Algorithmus: 1. Wähle einen Anfangssuchwert (Pivot-Element), z.b. das erste Element der (Teil-)Folge (zu Beginn: der Gesamtfolge) 2. Durchsuche die (Teil-)Folge von rechts beginnend, bis ein Element kleiner ist als das Pivot-Element 3. Durchsuche die (Teil-)Folge von links beginnend, bis ein Element größer ist als das Pivot-Element 4. Vertausche beide Elemente 5. Wiederhole die Schritte 2. bis 4. bis sich die Zeiger treffen und vertausche abschließend das am weitesten rechts befindliche Element der linken Teilfolge mit dem Pivot-Element. Dieses teilt nun die Folge in zwei neue (Teil-)Folgen. 6. Wiederhole die Schritte 1. bis 5. für alle entstandenen Teilmengen bis jede weniger als drei Elemente enthält (Rekursion) Seite 16

9 QuickSort (Hoare 1960) Seite 17 QuickSort void QuickSort (int arr[], long int links, long int rechts) { long int zl, zr; int hilf, pivot; if (rechts > links) { pivot = arr[rechts]; zl = links - 1; zr = rechts; do { while (arr[++zl] < pivot); while (arr[--zr] > pivot); if (zl >= zr) break; hilf = arr[zl]; arr[zl] = arr[zr]; arr[zr] = hilf; while(1); hilf = arr[zl]; arr[zl] = arr[rechts]; arr[rechts] = hilf; QuickSort (arr, links, zl-1); QuickSort (arr, zl+1, rechts); Seite 18

10 HeapSort Eine sortierte Folge heißt Heap, wenn für jedes Element a(k) gilt: a(k) >= a(2k) a(k) >= a(2k+1) "Peter-Prinzip": alle untergeordneten Knoten eines Binärbaumes haben kleinere Schlüsselwerte Beispiel (Heap in einem Array): a(1) > a(2); a(1) > a(3); a(2) > a(4); a(2) > a(5); a(3) > a(6); a(3) > a(7); usw. Seite 19 HeapSort Erzeugen einer Heap-Folge aus einer unsortierten Folge: Annahme: Die Teilfolge a(n/2), a((n/2)+1)... + a(n) sei bereits ein vorsortierter Heap Dann wird jedes kleinere Element ((a(n/2)-1),... a(1) einsortiert, indem es mit dem jeweils größeren seiner Nachfolger den Platz wechselt Seite 20

11 HeapSort Seite 21 HeapSort Sortieren in absteigender Reihenfolge: Das am weitesten oben stehende Element wird entfernt. Es bleiben zwei Teil-Heaps übrig. Diese werden vereint, indem das am weitesten unten stehende Element an den leeren Platz gesetzt wird und mit dem jeweils größeren seiner Nachfolger den Platz wechselt. Seite 22

12 HeapSort Seite 23 HeapSort Seite 24

13 HeapSort Seite 25 TreeSort Symmetrisches Durchmustern: _ 29 _ 36 _ Seite 26

14 MergeSort Algorithmus: 1. Teile die zu sortierende Folge in n Teilfolgen etwa gleicher Länge. 2. Sortiere jede Teilfolge mit einem beliebigen. 3. Mische die sortierten Teilfolgen: a) Setze die Anfangszeiger jeder Teilfolge auf 1 b) Nimm den kleinsten Wert, auf den ein Zeiger zeigt, in die Ergebnisfolge; setze diesen Zeiger um 1 weiter c) wiederhole Schritt b), solange in einer Teilfolge noch Werte stehen, für alle nichtleeren Teilfolgen Seite 27 MergeSort Unsortierte Menge teilen; Teilmengen sortieren Teilmengen mischen Seite 28

15 Bewertung Experimentelle Untersuchung: Erzeugung unterschiedlicher Mengen zufallsverteilter Ausgangsdaten Zeitmessung, bezogen auf den reinen Sortiervorgang, für verschiedene Datenmengen und verschiedene statistische Auswertung Theoretische Untersuchung: Analyse des Aufwandes (Speicherplatz-, Rechenzeitbedarf) in Abhängigkeit von der zu sortierenden Datenmenge Seite 29 Zeitmessungen Erzeugen unsortierter Daten Start- und Endzeit messen Versuchsparameter: zu sortierender Menge Rechnerleistung Reproduzierbarkeit gewährleisten statistische Auswertung Seite 30

16 Analyse von Algorithmen Zeitkomplexität Zeitbedarf von Komplexität des Problems abhängig Zuordnung einer Ganzzahl n als Ausdruck der Problemgröße hardware- und software-abhängige Einflüsse werden ignoriert, da Korrektheit und Effizienz eines Algorithmus nicht von Implementierung abhängig sind charakteristische Operationen des Algorithmus müssen in Abhängigkeit von der Problemgröße entsprechend viele Male ausgeführt werden z.b.: Suche von x in n Elementen: min. 1, max. n Vergleiche z.b.: Matrixmultiplikation n-ter Ordnung: n 3 Multipl. + n 2 *(n-1) Additionen Ausführungszeit ist dann: t = c * T(n) mit T(n) = Zeitkomplexität und c = implementierungsabhängige Konstante Seite 31 Analyse von Algorithmen Fallunterscheidungen tatsächliche Laufzeit abhängig von Anzahl Datenwerten, deren Werten und deren Verteilung Unterscheidung bester Fall: T best (n) = min (T i (n)) i I mittlerer Fall: T avg (n) = Σ T i (n) * p i i I schlechtester Fall: T worst (n) = max (T i (n)) i I schlechtester Fall häufig am leichtesten bestimmbar; sichere Seite Seite 32

17 Analyse von Algorithmen O-Notation häufig nicht genaue Laufzeit gesucht, sondern Größenordnung Vergleich der Zeitkomplexität T(n) mit bekannten Funktionen g(n) wie n 2, log 2 (n), n*log 2 (n) und deren Wachstum T(n) wächst in gleicher Größenordnung wie g(n), wenn es positive Konstanten c 0 und n 0 gibt, für die gilt: T(n) c 0 * g(n) für n n 0 man schreibt dann: T(n) = O(g(n)) und sagt: T(n) ist von der Ordnung g(n) O(g(n)) beschreibt schlechtesten Fall, also die obere Schranke der Laufzeit Gleichheitszeichen bezeichnet keine Identität! Seite 33 Zeitkomplexität g(n) n n*log2(n) n*n n Seite 34

18 Ermittlung der Zeitkomplexität Beispiel: SelectionSort (Instrumentierung) void SelectionSort (int arr[], long int anz) { int min; long int h,k,pos,f=0,v=0,z=0; for (h=0; h<anz-1; h++) { min = arr[h]; pos = h; f++; z++; z++; for (k=h+1; k<anz; k++) { f++; v++; if (arr[k] < min) { min = arr[k]; pos = k; z++; z++; arr[pos] = arr[h]; arr[h] = min; z++; z++; n Zuw Vergl Zyklen Seite 35 Vergleich von Sortieralgorithmen Verfahren QuickSort HeapSort schlechtester Fall ~0.5 * (n 2 n) ~2 * n * log 2 (n) mittlerer Fall ~1.4 * n * log 2 (n) 2.8 * n... ~2 * n * log 2 (n) +... Seite 36