Kapitel 11: Ausgewählte Algorithmen: Sortieren von Listen Einführung in die Informatik Wintersemester 2007/08 Prof. Bernhard Jung Übersicht Analyse von Algorithmen: Zeitkomplexität Elementare Sortierverfahren Bubble-Sort Insertion-Sort Divide-und-Conquer Verfahren zum Sortieren Merge-Sort Literatur G. Saake & K.-U. Sattler. Algorithmen und Datenstrukturen. dpunkt Lehrbuch. 2006. R. Sedgewick. Algorithmen. 2. Auflage. Addison Wesley. 2002. Donald Knuth. The Art of Computer Programming, Volume 3: Sorting and Searching, Third Edition. Addison-Wesley, 1997. The xsortlab Applet. http://math.hws.edu/tmcm/java/xsortlab/ 1
Auswahl von Algorithmen I.a. gibt es immer mehrere Algorithmen zur Lösung eines Problems diese unterscheiden sich jedoch häufig bzgl. grundlegender Leistungsmerkmale (abgesehen davon, dass sie dasselbe Ergebnis liefern), wie Bedarf an Zeit, Speicher und anderen Ressourcen Welcher Algorithmus sollte dann gewählt werden? 1. Einfachere Algorithmen sind komplizierten Algorithmen vorzuziehen leichter zu verstehen, schneller zu implementieren wenn Algorithmus nur wenige Male abgearbeitet werden muss, dann lohnt sich Entwicklungsaufwand für optimierte Algorithmen of nicht falls Geschwindigkeit und Speicherbedarf für Anwendung nicht ausreichend: 2. Schnellere, ressourcensparende Algorithmen bevorzugen Kenntnis der Leistungsmerkmale wichtig Bewertung von Algorithmen: Zeitkomplexität Bewertung von Algorithmen Wie viele Computer-Ressourcen benötigt Ausführung des Algorithmus? hauptsächlich: Zeit, Speicher; auch Anzahl Prozessoren Maß für Zeitkomplexität (Ausführungszeit) Anzahl Operationen der Algorithmenausführung in Proportion zur Größe der Eingabe z.b. "Größe der Eingabe" bei Listen: n = Länge der Liste Grobe Abschätzung dabei pragmatisch ausreichend z.b. "proportional zu n", "proportional zu n 2 " mit n Größe der Eingabe d.h. Abstraktion von Ausführungsgeschwindigkeit von Programmen auf spezifischer Hardware 2
Theorie der Algorithmen Zeitkomplexität Beispiel: Zeitkomplexität des Standard-Multiplikations-Algorithmus 1984 * 6713 ----------- 11904 13888 1984 5952 ----------- 13318592 Multiplikation zweier n-stelligen Zahlen: jede Zeile kann in n Schritten (Zeiteinheiten) berechnet werden; es gibt n Zeilen es müssen n Zeilen mit jeweils n (oder n+1) Ziffern addiert werden Ausführungszeit proportional zu n*n oder n 2 Analyse von Algorithmen: Typische Zeitkomplexitäten konstant (proportional zu 1) logarithmisch (proportional zu log n) linear (proportional zu n) n log n quadratisch (proportional zu n 2 ) polynomial (proportional zu n k für k 1) exponentiell (proportional zu d n für d > 1) 3
Begründung für grobe Abschätzung der Zeitkomplexität von Algorithmen betrachte Funktionen f(n) = n g(n) = 50 n h(n) = n 2 für große n gilt n 2 >> c n für beliebiges c h(n) = n 2 g(n) = 50 n daher Unterscheidung bzgl. grobem Wachstumsverhalten "proportional zu n" "proportional zu n 2 " von konstanten Faktoren wird (zunächst) abgesehen n, 2 n, 50 n, usw. alle "proportional zu n" "asymptotische Komplexität" f(n) = n (Diagramm erzeugt mit 4-Zeiler in Python + matplotlib) Ausführungszeiten für Algorithmen unterschiedlicher Zeitkomplexität Größe n der Eingabedaten log 2 n Mikrosekunden n Mikrosekunden n 2 Mikrosekunden 2 n Mikrosekunden 10 0.000003 0.00001 0.0001 0.001 100 0.000007 0.0001 0.01 10 14 Jahrhunderte 1000 0.00001 0.001 1 Sekunde astronomisch 10000 0.000013 0.01 1.7 Minuten astronomisch 100000 0.000017 0.1 2.8 Stunden astronomisch 4
Bester, schlechtester und durchschnittlicher Fall in Bezug auf die in Frage stehende Ressource (z.b. Zeit- oder Speicherbedarf) werden Algorithmen untersucht auf: Schlechtester Fall: Wie arbeitet der Algorithmus im schlimmsten Fall? wichtigstes Maß wenn bei Charakterisierung der Teitkomplexeität eines Algorithmus Fall nicht angeben, dann bezieht sich Aufwandsangabe auf schlechtesten Fall Durchschnittlicher Fall: Wie arbeitet der Algorithmus durchschnittlich? auch häufig betrachtet die zugrunde zu legende Verteilung für die Berechnung eines Durchschnitts ist aber nicht immer offensichtlich! Bester Fall: Wie arbeitet der Algorithmus im günstigsten Fall? nur manchmal von Interesse oft trügerisch Sortier-Algorithmen Sortieren von Listen z.b. [5,3,4,1,2] [1,2,3,4,5] auch lexikographisches Sortieren von Listen mit String-Elementen: z.b. ['bob', 'carl', 'alice'] ['alice', 'bob', 'carl'] Sortieren ist grundlegendes Problem in der Informatik! ca. ¼ der kommerziell verbrauchten Rechenzeit fällt auf Sortiervorgänge (nach: Ottmann & Widmayer. Algorithmen und Datenstrukturen. 2002) In der Informatik ist eine Vielzahl von Sortieralgorithmen bekannt Eigenschaften wie Zeitkomplexität sind gut untersucht im folgenden: drei Algorithmen dargestellt s.a. http://de.wikipedia.org/wiki/sortieralgorithmen 5
Sortier-Algorithmus 1: Bubble-Sort Idee Bubble-Sort Wiederholtes Vertauschen von benachbarten Elementen, die in falscher Reihenfolge stehen; dazu i.a. mehrere Durchläufe notwendig Name rührt daher, dass in jedem Durchlauf große Elemente "wie Blasen im Wasser" ihrer endgültigen Position entgegenstreben Auch bekannt als "Sortieren durch Vertauschen" Algorithmus in Pseudo-Code Schleife über Durchlauf = 1.. N-1 Schleife über Position = 0.. N-1-Durchlauf Falls x[position] > x[position+1] dann Vertausche x[position] und x[position+1] Sortier-Algorithmus 1: Bubble-Sort Veranschaulichung 1. Durchlauf danach: größtes Element in endgültiger Position nach 10 Durchläufen: 10 größte Elemente in endgültiger Position allg: nach (n-1) Durchläufen ist Liste sortiert 6
Sortier-Algorithmus 1: Bubble-Sort Zeit-Komplexität Anzahl Vergleichsoperationen Durchgänge äußere Schleife: (n-1)-mal (n = Größe der Liste) Durchgänge innere Schleife (= Anz. Vergleichsoperationen): (n-1) + (n-2) + (n-3) +.. + 3 + 2 + 1 ~ n 2 / 2 Ausführungszeit des Alg. proportional zu n 2 (bester, schlimmster und durchschnittlicher Fall) Algorithmus in Pseudo-Code Schleife über Durchlauf = 1.. N-1 Schleife über Position = 0.. N-1-Durchlauf Falls x[position] > x[position+1] dann Vertausche x[position] und x[position+1] Sortier-Algorithmus 1: Bubble-Sort Python-Implementierung Algorithmus in Pseudo-Code Schleife über Durchlauf = 1.. N-1 Schleife über Position = 0.. N-1-Durchlauf Falls x[position] > x[position+1] dann Vertausche x[position] und x[position+1] Implementierung in Python def bubblesort(l): for durchgang in range( 1, len(l) ): for index in range( len(l) - durchgang ): if l[index] > l[index + 1]: l[index], l[index + 1] = l[index + 1], l[index] return l 7
Sortier-Algorithmus 1: Bubble-Sort Trace der Python-Implementierung bubblesort( [5, 3, 5, 4, 2, 1] ) Eingabe: nach Durchgang 1 : [3, 5, 4, 2, 1, 5] nach Durchgang 2 : [3, 4, 2, 1, 5, 5] nach Durchgang 3 : [3, 2, 1, 4, 5, 5] nach Durchgang 4 : [2, 1, 3, 4, 5, 5] nach Durchgang 5 : [1, 2, 3, 4, 5, 5] Ergebnis: [1, 2, 3, 4, 5, 5] Eingabeliste der Länge 6 5 Durchgänge bubblesort( [2, 6, 5, 3, 4] ) nach Durchgang 1 : [2, 5, 3, 4, 6] nach Durchgang 2 : [2, 3, 4, 5, 6] nach Durchgang 3 : [2, 3, 4, 5, 6] nach Durchgang 4 : [2, 3, 4, 5, 6] Ergebnis: [2, 3, 4, 5, 6] Eingabeliste der Länge 5 4 Durchgänge Beobachtung: Liste schon nach 2. Durchgang sortiert! Sortier-Algorithmus 1: Bubble-Sort Verbesserte Variante Verbesserung von Bubble-Sort möglich, indem Algorithmus abgebrochen wird, sobald sich in einem Durchgang keine Veränderungen mehr ergeben dazu Einführung einer booleschen Variable, die überprüft ob im aktuellen Durchgang noch Listenelemente vertauscht werden def bubblesort2(l): for durchgang in range( 1, len(l) ): bubbling = False for index in range( len(l) - durchgang ): if l[index] > l[index + 1]: l[index], l[index + 1] = l[index + 1], l[index] bubbling = True if not bubbling: return l return l 8
Sortier-Algorithmus 1: Bubble-Sort Trace der Python-Implementierung, verbesserte Variante bubblesort2( [5, 3, 5, 4, 2, 1] ) nach Durchgang 1 : [3, 5, 4, 2, 1, 5] nach Durchgang 2 : [3, 4, 2, 1, 5, 5] nach Durchgang 3 : [3, 2, 1, 4, 5, 5] nach Durchgang 4 : [2, 1, 3, 4, 5, 5] nach Durchgang 5 : [1, 2, 3, 4, 5, 5] Ergebnis: [1, 2, 3, 4, 5, 5] Eingabeliste der Länge 6 immernoch 5 Durchgänge bubblesort2( [2, 6, 5, 3, 4] ) nach Durchgang 1 : [2, 5, 3, 4, 6] nach Durchgang 2 : [2, 3, 4, 5, 6] nach Durchgang 3 : [2, 3, 4, 5, 6] Ergebnis: [2, 3, 4, 5, 6] Eingabeliste der Länge 5, etwas besser 'vorsortiert' nur noch 3 Durchgänge bubblesort2( [1, 2, 3, 4, 5] ) nach Durchgang 1 : [1, 2, 3, 4, 5] Ergebnis: [1, 2, 3, 4, 5] Eingabeliste schon sortiert nur noch 1 Durchgang! Sortier-Algorithmus 1: Bubble-Sort Zeitkomplexität Zusammenfassung Bester Fall Proportional zu n Eingabe-Liste schon sortiert Schlechtester Fall Proportional zu n 2 z.b. Eingabe-Liste rückwärts sortiert Durchschnittlicher Fall Proportional zu n 2 d.h. Liste zufällig gemischt Zeitkomplexität Bubble-Sort, verbesserte Variante n = Länge der Liste 9
Sortier-Algorithmus 2: Insertion-Sort oder Suchen durch Einfügen Analogie zum Aufnehmen eines Stapels bei Kartenspiel: Nimm sukzessiv je eine Karte auf und ordne diese sortiert in einen zweiten Stapel ein def insertionsort(unsorted): sorted = [] for x in unsorted: insert(x, sorted) return sorted eine zweite Liste sorted wird erzeugt, anfangs leer fügt x an richtiger Stelle in die Liste sorted ein (Implementierung von insert nicht gezeigt) Sortier-Algorithmus 2: Insertion-Sort Trace der Python-Implementierung def insertionsort(unsorted): sorted = [] for x in unsorted: insert(x, sorted) return sorted insertionsort( [5, 3, 5, 4, 2, 1] ) sorted nach 1. Durchgang: [5] sorted nach 2. Durchgang: [3, 5] sorted nach 3. Durchgang: [3, 5, 5] sorted nach 4. Durchgang: [3, 4, 5, 5] sorted nach 5. Durchgang: [2, 3, 4, 5, 5] sorted nach 6. Durchgang: [1, 2, 3, 4, 5, 5] Sukzessiver Aufbau einer sortierten Liste, bis alle Elemente einsortiert sind Ergebnis: [1, 2, 3, 4, 5, 5] Nachteil des Alg.: Erzeugung einer zweiten Liste benötigt zus. Speicherplatz Variante, bei welcher die Eingabe-Liste in-place ("am Ort") sortiert wird 10
Sortier-Algorithmus 2: Insertion-Sort In-Place Variante Idee: Eingabeliste selbst wird konzeptuell aufgeteilt ein einen bereits sortierten Bereich (vorne) und einen unsortierten Bereich (hinten) keine weitere Kopie der Liste notwendig, Liste wird in-place sortiert sortierter Bereich hat zunächst Länge 1 (Teilliste mit nur einem Element) danach wird pro Schleifendurchgang 1 Element aus dem hinteren Bereich in den vorderen Bereich einsortiert def insertionsort2(l): for i in range(1,len(l)): j = i m = l[i] while j > 0 and l[j-1]>m: l[j] = l[j-1] j -= 1 l[j]=m return l insertionsort2( [5, 3, 5, 4, 2, 1] ) vor 1. Durchgang: [5, 3, 5, 4, 2, 1] nach Durchgang 1: [3, 5, 5, 4, 2, 1] nach Durchgang 2: [3, 5, 5, 4, 2, 1] nach Durchgang 3: [3, 4, 5, 5, 2, 1] nach Durchgang 4: [2, 3, 4, 5, 5, 1] nach Durchgang 5: [1, 2, 3, 4, 5, 5 ] Ergebnis: [1, 2, 3, 4, 5, 5 ] sortierter Bereich unsortierter Bereich Sortier-Algorithmus 2: Insertion-Sort Zeitkomplexität In-Place Variante Äußere Schleife wird (n-1) mal durchlaufen d.h. proportional zu n Anzahl Durchläufe der inneren Schleife (while) ist abhängig von Bedingung l[j-1] > m def insertionsort2(l): for i in range(1,len(l)): j = i m = l[i] while j > 0 and l[j-1]>m: l[j] = l[j-1] j -= 1 l[j]=m return l und somit Sortierungsgrad der Liste variiert von 0 bis (n-1) Durchläufen pro Durchgang der äußeren Schleife Bester Fall Eingabe-Liste schon sortiert Schlechtester Fall z.b. Eingabe-Liste rückwärts sortiert Durchschnittlicher Fall Proportional zu n Proportional zu n 2 Proportional zu n 2 Zeitkomplexität Insertion-Sort, in-place Variante n = Länge der Liste gleiche asymptotische Zeitkomplexität wie Bubble-Sort! 11
Empirischer Vergleich (Laufzeit) verschiedener Suchverfahren Vergleich dreier elementare Suchverfahren Zeitkomplexität im schlimmsten und durchschnittlichen Fall jeweils proportional zu n 2 Messung der Laufzeit zeigt aber, dass Bubble-Sort ca 3-mal langsamer als Insertion- Sort Source: O. Astrachan. Bubble Sort: An Archaeological Algorithmic Analysis. http://www.cs.duke.edu/~ola/papers/bubble.pdf Sortier-Algorithmus 3: Merge-Sort Beispiel für Teile-und-Herrsche (Divide and Conquer) Methode Idee Sortieren ist einfacher für kurze als für lange Listen insbesondere sind Listen mit nur einem Element schon sortiert konkret Teile Liste in zwei kleinere Teil-Listen sortiere die Teil-Listen (evtl. durch weiteres Teilen) Verschmelze die sortierten Teil-Listen zum Endergebnis Bild: wikipedia.de 12
Sortier-Algorithmus 3: Merge-Sort Bild: wikipedia.de Sortier-Algorithmus 3: Merge-Sort Zeitkomplexität Pseudocode für Algorithmus Merge-Sort Funktion sort(liste) falls len(liste) > 1 teil1, teil2 split(liste) teil1 = sort(teil1) teil2 = sort(teil2) liste = merge(teil1, teil2) kann gezeigt werden: Ausführungszeit von Merge-Sort proportional zu n * log n, mit n Größe der Eingabeliste (schlechtester, durchschnittlicher und bester Fall) bessere Zeitkomplexität als Bubble-Sort, Insertion-Sort kann auch gezeigt werden: minimale Ausführungszeit für beliebige Algorithmen zur Lösung des Problems "Sortieren von Listen der Länge n" ist proportional zu n log n Merge-Sort ist optimaler Sortieralgorithmus (bzgl. Zeitkomplexität) 13
Zusammenfassung (1) bei kleinen Listen liefern i.d.r. alle Sortierverfahren sehr schnell Ergebnisse wenn in Anwendung nur kleine Listen vorkommen und kein besonderer Echtzeitbedarf besteht, dann kann beliebiger Alg. verwendet werden bei großen Listen, z.b. ab 100 Elementen, spielt Zeitkomplexität der Algorithmen eine entscheidende Rolle n log n Algorithmen (z.b. merge-sort) immer besser als n 2 Algorithmen (insertion sort, bubble sort) auch bei gleicher Zeitkomplexität zweier Algorithmen bestehen manchmal deutliche Unterschiede bzgl. tatsächlicher Laufzeit z.b. insertion-sort praktisch immer schneller als bubble-sort in speziellen Fällen kann Verwendung von insertion-sort o.ä. gegenüber n log n Algorithmus vorteilhaft sein: nämlich dann, wenn Liste fast immer vorsortiert ist dann durchschnittliche Zeitkomplexität von insertion-sort proportional zu n z.b. bei bestimmten Verfahren zur Kollisionserkennung in Echtzeit 3D-Computergraphik Zusammenfassung (2) Für die meisten praktischen Fälle liefern die Sortierverfahren der Standardbibliotheken der jeweiligen Programmiersprachen sehr gute Ergebnisse diese Implementierungen sind i.d.r. hochgradig optimiert z.b. Python: sort()-methode >>> l = ['T','U','-','B','A','F'] >>> l.sort() >>> print l ['-', 'A', 'B', 'F', 'T', 'U'] >>> 14