Kapitel 3: Sortierverfahren Gliederung

Transkript

1 Gliederung 1. Grundlagen 2. Zahlentheoretische Algorithmen 3. Sortierverfahren 4. Ausgewählte Datenstrukturen 5. Dynamisches Programmieren 6. Graphalgorithmen 7. String-Matching 8. Kombinatorische Algorithmen 9. Lineare Programmierung 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

2 Gliederung des Kapitels u Fahrplan Problemstellung Sortieren durch Vergleichen lineares Sortieren paralleles Sortieren 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

3 Problemstellung und Relevanz u Problemstellung zulässige Eingaben: Schlüsselfolge a[1],...,a[n] zulässige Ausgaben: Schlüsselfolge b[1],...,b[n] mit: 1. b[i] b[i+1] für alle i mit 1 i n { b[1],...,b[n] } = { a[1],...,a[n] } u... untersuchungswürdig, weil Sortieren praktisch wichtig ist Sortieren ein leichtes Problem ist Sortieren algorithmen-methodisch interessant ist... 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

4 Sortieren durch Vergleichen u Grundannahmen die Schlüssel der zu sortierenden Folge sind in einem Array gespeichert es stehen die folgenden Elementaroperationen zur Verfügung Vergleich von zwei Elementen des Arrays (/* compare(.,.) */) Vertauschen von zwei Elementen des Arrays (/* swap(.,.) */)... die Komplexitätsfunktion eines Verfahrens zum Sortieren durch Vergleichen gibt - in Abhängigkeit von der Länge der gegebenen Schlüsselfolge - an, wie viele Vergleichs- und Vertauschoperationen im worst case nötig sind, um die Schlüsselfolge zu sortieren... eine ganze Reihe von Verfahren zum Sortieren durch Vergleichen sind Ihnen aus der Vorlesung Programmieren bekannt 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

5 Sortieren durch Vergleichen InsertionSort u algorithmische Idee für i = 2, 3,..., n betrachte die Teilfolge der ersten i vielen Elemente bringe das letzte Element dieser Teilfolge an seine richtige Stelle i = i = i = /1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

6 Sortieren durch Vergleichen InsertionSort u algorithmische Idee für i = 2, 3,..., n betrachte die Teilfolge der ersten i vielen Elemente bringe das letzte Element dieser Teilfolge an seine richtige Stelle i = diesen Vergleich kann man sich sparen, weil... i = i = /1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

7 Sortieren durch Vergleichen InsertionSort u Implementierung for ( i = 2; i <= n; ++i ) { int j = i; while ( j > 1 && compare(a[j-1], a[j]) == false ) { swap(a[j-1], a[j]); --j; } }...die Anzahl der durchzuführenden Vergleichs- und Vertauschoperationen hängt von der konkreten Schlüsselfolge ab best case worst case /1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

8 Sortieren durch Vergleichen InsertionSort u Analyse (/* best case */) mehr Vergleichs- als Vertauschoperationen Anzahl der Vergleichsoperationen (/* je Schleifendurchlauf */) i = 2: 1 Vergleich i = 3: 1 Vergleich... i = n: 1 Vergleich insgesamt: n - 1 Vergleiche 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

9 Sortieren durch Vergleichen InsertionSort u Analyse (/* worst case */) mehr Vergleichs- als Vertauschoperationen Anzahl der Vergleiche (/* je Schleifendurchlauf */) i = 2: 1 Vergleich i = 3: 2 Vergleiche... i = n: n - 1 Vergleiche insgesamt: 1/2*(n*(n - 1)) Vergleiche 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

10 Sortieren durch Vergleichen InsertionSort u Zusammenfassung InsertionSort macht offenbar das, was es soll (/* es sortiert korrekt, weil... */) InsertionSort hat im worst case eine Komplexität von Θ(n 2 ), wobei n die Länge der zu sortierenden Folge bezeichnet abgeleitete Frage: Gibt es Verfahren zum Sortieren durch Vergleichen, die eine Komplexität (/* im worst case */) kleiner als Θ(n 2 ) haben? 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

11 Sortieren durch Vergleichen MergeSort u Einordnung ein Verfahren zum Sortieren durch Vergleichen, das im worst case die Komplexität Θ(n*log(n)) hat basiert auf einer einfachen Idee die Komplexität dieses Verfahrens läßt sich einfach abschätzen einziger Nachteil: es wird zusätzlicher Speicherplatz benötigt 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

12 Sortieren durch Vergleichen MergeSort u Ansatzpunkt es seien a[1],...,a[n] die gegebene Folge und b[1],...,b[n] die gesuchte aufsteigend sortierte Variante dieser Folge es sei c[1],...,c[n/2] die aufsteigend sortierte Variante der Teilfolge a[1],...,a[n/2] und c[n/2+1],...,c[n] die aufsteigend sortierte Variante der Teilfolge a[n/2+1],...,a[n]... dann ergibt sich b[1],...,b[n] durch Verschmelzen der Teilfolgen c[1],...,c[n/2] und c[n/2+1],...,c[n]... hierzu genügen n-1 Vergleiche 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

13 Sortieren durch Vergleichen MergeSort u Beispiel /1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

14 Sortieren durch Vergleichen MergeSort u algorithmische Idee (/* Divide & Conquer */) Divide Schritt: Conquer Schritt: Merge Schritt: bestimme die Folgen a[1],...,a[n/2] und a[n/2+1],...,a[n] sortiere die beiden Folgen a[1],...,a[n/2] und a[n/2+1],...,a[n] mittels MergeSort (/* Ergebnis: c[1],...,c[n/2] und c[n/2+1],...,c[n] */) verschmelze die beiden Folgen c[1],...,c[n/2] und c[n/2+1],...,c[n] zur sortierten Folge b[1],...,b[n] 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

15 Sortieren durch Vergleichen MergeSort u Illustration /1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

16 Sortieren durch Vergleichen MergeSort u Illustration /1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

17 Sortieren durch Vergleichen MergeSort u Analyse (/* worst case */) es bezeichne V(A,n) die Anzahl der Vergleichs- und Vertausch- Operationen, die MergeSort bei Eingabe einer Schlüsselfolge der Länge n benötigt Divide Schritt: 0 Vergleichs- und Vertausch-Operationen Conquer Schritt: 2*V(A,n/2) viele Vergleichs- und Vertausch- Operationen Merge Schritt: n - 1 viele Vergleichs- und n Vertausch- Operationen Es gilt: V(A,n) = 2*V(A,n/2) + 2n - 1. Damit gilt: V(A,n) Θ(n*log(n)). 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

18 Sortieren durch Vergleichen MergeSort u Zusammenfassung MergeSort macht offenbar das, was es soll (/* es sortiert korrekt, weil... */) MergeSort hat im worst case eine Komplexität von Θ(n*log(n)), wobei n die Länge der zu sortierenden Folge bezeichnet MergeSort benötigt ein zusätzliches Array der Größe n, damit im Merge -Schritt das Verschmelzen effizient implementiert werden kann... es gibt kein Verfahren zum Sortieren durch Vergleichen, das im worst case eine Komplexität kleiner als Θ(n*log(n)) hat 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

19 Sortieren durch Vergleichen eine untere Schranke u Zielstellung diskutieren, wie man beweisen kann, daß es kein Verfahren zum Sortieren durch Vergleichen geben kann, das im worst case eine Komplexität kleiner gleich Θ(n*log(n))... problematisch ist, daß wir gar nicht alle Verfahren zum Sortieren durch Vergleichen kennen (/* manche sind noch gar nicht entwickelt worden */)... wir müssen daher besser verstehen, was allen Verfahren zum Sortieren durch Vergleichen gemeinsam ist 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

20 Sortieren durch Vergleichen eine untere Schranke u Grundidee es sei A ein Verfahren zum Sortieren durch Vergleichen und n die Länge der zu sortierenden Folge dann kann man A und n einen Entscheidungsbaum zuordnen (/* in diesem Baum wird Buch geführt über die Vergleiche, die A beim Sortieren einer Folge der Länge n durchführt */)... um eine untere Schranke für das Sortieren durch Vergleichen abzuleiten, genügt es Entscheidungsbäume besser zu verstehen und deren Eigenschaften zu analysieren (/* wichtig ist, daß wir nur Entscheidungsbäume analysieren, die potentiell einem Verfahren zum Sortieren durch Vergleichen zugeordnet werden können */) 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

21 Sortieren durch Vergleichen eine untere Schranke u Beispiel - Entscheidungsbaum für InsertionSort (/* n = 3 */) 1:2 > 2:3 1:3 > > <1,2,3> 1:3 > <2,1,3> 2:3 > <1,3,2> <3,1,2> <2,3,1> <3,2,1> jeder innerer Knoten (/* i:j */) ist mit einem Vergleich von Folgenelementen versehen (/* kurz für: a[i] a[j] */) jedes (/* <i,j,k> */) Blatt ist mit einer Permutation der Elemente der gegebenen Folge versehen (/* kurz für: a[i],a[j],a[k] */) 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

22 Sortieren durch Vergleichen eine untere Schranke u Erzeugung des zugeordneten Entscheidungsbaums es sei A ein Verfahren zum Sortieren durch Vergleichen und n die Länge der zu sortierenden Folge die Wurzel ist mit dem ersten Vergleich versehen, den A durchführt es sei K ein innerer Knoten, der mit dem Vergleich i:j versehen ist der linke Sohn wird mit dem Vergleich versehen, der von A als nächstes durchgeführt wird, falls a[i] a[j] gilt der rechte Sohn wird mit dem Vergleich versehen, der von A als nächstes durchgeführt wird, falls a[i] > a[j] gilt falls kein Vergleich mehr durchgeführt wird, so wird ein Blatt erzeugt (/* die Permutation, mit der das Blatt versehen wird, wird durch die auf dem Pfad von der Wurzel zu diesem Blatt durchgeführten Vergleiche festgelegt */) 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

23 Sortieren durch Vergleichen eine untere Schranke u Illustration 1:2 > 2:3 1:3 > > <1,2,3> 1:3 > <2,1,3> 2:3 > <1,3,2> <3,1,2> <2,3,1> <3,2,1> da a[1] a[2] und a[2] a[3] gilt, steht hier die Permutation <1,2,3> da a[1] > a[2], a[1] >a[3] und a[2] a[3] gilt, steht hier die Permutation <2,3,1> 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

24 Sortieren durch Vergleichen eine untere Schranke u Beobachtungen es sei A ein Verfahren zum Sortieren durch Vergleichen und n die Länge der zu sortierenden Folge Dem Paar (A,n) ist auf eindeutige Weise ein Entscheidungsbaum B zugeordnet. Jedem Pfad von der Wurzel zu einem Blatt entspricht einer Berechnung des Verfahrens A bei Eingabe einer Folge der Länge n. (/* Die Permutation, mit der das Blatt versehen ist, beschreibt das Ergebnis der Berechnung, die in diesem Blatt endet. */). Wenn das Verfahren A in der Lage ist, jede Folge der Länge n zu sortieren, so muß B so viele Blätter enthalten, wie es Permutationen von Folgen der Länge n gibt (/* also n! viele Permutationen */). 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

25 Sortieren durch Vergleichen eine untere Schranke u Folgerung um eine untere Schranke für die Komplexität von Verfahren zum Sortieren durch Vergleichen (/* im worst case */) abzuleiten, genügt es eine untere Schranke für die Tiefe aller Entscheidungsbäume mit mindestens n! vielen Blättern anzugeben... zugrunde liegende Zuordnung die Anzahl der Vergleiche einer Berechnung entspricht der Anzahl der inneren Knoten in dem zu dieser Berechnung gehörenden Pfad von der Wurzel zum Blatt die Tiefe eines Entscheidungsbaums entspricht der Anzahl der inneren Knoten auf einem längsten Pfad von der Wurzel zu einem Blatt 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen

26 Sortieren durch Vergleichen eine untere Schranke u Ergebnis und Begründung Jedes Verfahren zum Sortieren durch Vergleichen hat im worst case eine Komplexität von Ω(n*log(n)), wobei n die Länge der zu sortierenden Folge bezeichnet.... der zugehörige Entscheidungsbaum hat n! viele Blätter... der zugehörige Entscheidungsbaum ist ein Binärbaum... jeder Binärbaum der Tiefe t hat höchstens 2 t viele Blätter zugehörige Entscheidungsbaum B muß eine Tiefe t mit 2 t n! haben (/* sonst hat er zu wenige Blätter */) also muß t log(n!) gelten wegen log(n!) n*log(n), muß also t n*log(n) gelten 3/1, Folie Prof. Steffen Lange - HDa/FbI - Effiziente Algorithmen