Datenstrukturen & Algorithmen Matthias Zwicker Universität Bern Frühling 2010
Übersicht Sortieralgorithmen Einleitung Heapsort Quicksort 2
Motivation Sortieren ist Voraussetzung für viele Anwendungen Nach Bestellnummern sortierte Aufträge, etc. Viele Algorithmen enthalten Sortierschritte Suchen GUIs (graphical user interfaces) Zeichnen von grafischen Objekten die sich gegenseitig verdecken Objekte sollen gemäss liegt vor oder liegt hinter Relation geordnet werden In kommerzieller Datenverarbeitung wird mehr als 25% der Rechenzeit mit Sortieren verbracht 3
Records und Keys Datensatz besteht aus Menge von Records Jeder Record enthält einen Key (Schlüssel) und zusätzliche Daten ( Satellitendaten ) Daten werden anhand der Schlüssel sortiert class Record { int key; SatelliteData data; } class SatelliteData{ String name; String address;... } 4
Übersicht Sortieralgorithmen Einleitung Heapsort Quicksort 5
Ausgangslage Sortiere Sequenz von ganzen Zahlen Sortieren von Records mit Keys im Prinzip i gleich Eingabe: Zahlen <a 1, a 2,..., a n > Ausgabe: Permutation <a 1 1, a 2 a 2,..., a n > so dass a 1 <= a 2, <=... <= a n Beispiel Eingabe: 8 2 4 9 3 6 Ausgabe: 234689 6
Heapsort Suchverfahren mit Zeitkomplexität O(n lg n) In-placeVerfahren Speichert nur konstante Anzahl Elements ausserhalb des Eingabefeldes Sortieren durch Mischen (Merge Sort) ist nicht in-place! Heap Datenstruktur zur Verwaltung der Daten Heaps auch nützlich in anderen Algorithmen Prioritätswarteschlangen 7
Heaps Felder mit einer zusätzlichen Struktur Heap A länge[a] Anzahl Elemente des Feldes heap-grösse[a] Anzahl Elemente im Heap Heap kann als Binärbaum angesehen werden Jeder Knoten des Baumes entspricht einem Element des Feldes Reihenfolge wie in Skizze 1 heap-grösse[a] länge[a] 2 3 123456789101112 4 5 6 7 8 9 10 Feld A Darstellung als Binärbaum 8
Heaps Wurzel A[1] Berechnung der Indizes Vater[i] { return floor[i/2]; } Left[i] { return 2*i; } Right[i] { return 2*i+1; } 1 heap-grösse[a] länge[a] 2 3 123456789101112 4 5 6 7 8 9 10 Feld A Darstellung als Binärbaum 9
Heap Eigenschaft Max-Heap A[Vater(i)]>=A[i] Min-Heap A[Vater(i)]<=A[i] 1 heap-grösse[a] länge[a] 2 16 3 14 10 4 5 6 7 1 2 3 4 5 6 7 8 9 101112 8 7 9 3 161410 8 7932 4 1 xx 8 9 10 2 4 1 Feld A Darstellung als Binärbaum Max-Heap 10
Aufrechterhaltung der Heapeigenschaft Ausgangslage Gegeben Index i Bäume ausgehend von Left(i) und Right(i) sind Heaps Knoten i verletzt Heapeigenschaft 11
Aufrechterhaltung der Heapeigenschaft Max-Heapify(A,2) 1 1 2 16 3 2 3 4 4 5 6 10 7 4 5 6 7 14 7 9 3 8 9 10 8 9 10 2 8 1 1 2 3 4 5 6 7 8 9 10 12
Laufzeit Zugriff auf Knoten A[i], A[Left(i)] und A[Right(i)] in Θ(1) Von Kindern ausgehende Bäume haben höchstens 2n/3 Knoten Lösung von T (n) T (2n/3) + Θ(1) mit Mastertheorem ergibt T (n) = O(lg( g n) ) 13
Heap Konstruktion Bottom-up Max-Heapify Durchlaufe alle Knoten (ausser Blätter) und führe auf jedem Max-Heapify aus Korrektheit: Schleifeninvariante jeder Knoten i+1, i+2,, n ist Wurzel eine Max- Heap Laufzeit O(n) (siehe Buch) 14
Heap Konstruktion 12345678910 413216 9 101487 1 2 3 1 2 3 4 5 6 7 4 5 6 7 8 9 10 8 9 10 1 1 2 3 2 3 4 5 6 7 4 5 6 7 8 9 10 8 9 10 15
Heap Konstruktion 12345678910 413216 9 101487 2 4 3 4 1 5 6 10 7 14 16 9 3 8 9 10 2 8 7 1 1 2 3 4 5 6 7 8 9 10 2 3 4 5 6 7 8 9 10 16
Heap Sort 1. Konstruiere Heap 2. Verschiebe grösstes Element im Heap an sortierte Position bis Heap leer Nach jeder Verschiebung Heap Eigenschaft aufrechterhalten 17
Heap Sort 1 2 16 3 4 14 5 6 10 7 8 7 9 3 8 9 10 2 4 1 1 2 3 4 5 6 7 8 9 10 1 1 2 3 2 3 4 5 6 7 8 9 10 4 5 6 7 8 9 10 18
Heap Sort 1 2 9 3 4 8 5 6 3 7 4 7 1 2 8 9 10 10 14 16 1 2 3 4 5 6 7 8 9 10 1 1 2 3 2 3 4 5 6 7 8 9 10 4 5 6 7 8 9 10 19
Heap Sort 1 2 4 3 4 2 5 6 3 7 1 7 8 9 8 9 10 10 14 16 1 2 3 4 5 6 7 1 2 3 4 5 6 7 8 9 10 12345678910 8 9 10 20
Aufwand Heap Konstruktion Aufrechterhaltung der Heap Eigenschaft Total 21
Prioritätswarteschlangen (Priority queues) Datenstruktur zur Verwaltung einer Menge von Elementen, wobei jedes Element einen Schlüssel hat Operationen Insert: Einfügen eines neuen Elements Maximum: Abfragen des Elements mit grösstem (kleinstem) Schlüssel Extract-Max: Entfernen des Elements mit grösstem (kleinsten) Schlüssel Increase-Key: Verändern des Schlüssels eines Elements 22
Anwendungen Verwaltung von Arbeitsaufträgen geordnet nach Prioritäten (Zeitplanung, Scheduling) Rechenaufträge auf gemeinsam genutztem Rechner Prozessverwaltung in Multitaskingtas Implementation mit Heap Datenstruktur 23
Implementation mit Heaps 24
Implementation mit Heaps 25
Übersicht Sortieralgorithmen Einleitung Heapsort Quicksort 26
Quicksort Entwickelt von C. A. R. Hoare in 1962 Teile-und-beherrsche (divide-and-conquer) Schema Sortiert in-place Beliebt in Praxis Gilt als einer der schnellsten Sortieralgorithmen für grosse Datensätze 27
Teile-und-beherrsche Sortiere ein Feld A mit n Elementen 1. Teile: Zerlege Feld in zwei Teilfelder ld um ein Pivot q, so dass Elemente links von q <=A[q]<= Element rechts von q x x x x = A[q] q 2. Beherrsche: Sortiere Teilfelder rekursiv 3. Verbinde: Trivial Schlüssel zum Erfolg: Zerlegung des Felds in linearer Zeit 28
Zerlegung des Felds 29
Zerlegung des Felds Schleifeninvariante 30
Schleifeninvariante p i j r >x x x >x p i j r x x x >x 31
Beispiel 6 10 13 5 8 3 2 11 32
Beispiel p i j r 6 10 3 13 8 3 2 11 33
Quicksort Aufruf Quicksort(A,1,länge[A]) 34
Analyse Annahme: keine doppelten Elemente Alle Elemente sind verschieden 35
Worst case Eingabe ist sortiert Zerlegung immer um grösstes oder kleinstes Element Je nachdem ob Eingabe aufsteigend oder absteigend sortiert t war Eine Seite der Zerlegung ist leer T (n) =T (0) + T (n 1) + Θ(n) 36
Worst case Rekursionsbaum T (n) = T (0) + T (n 1) + Θ(n) 37
Best case Nur für Intuition Gleichmässige Zerlegung T (n) = 2T (n/2) + Θ(n) = Θ(n lg n) 1 10 : 9 10 Was wenn Zerlegung im Verhältnis? T (n) = T ( 1 9 10 n) + T ( 10 n) + Θ(n) Rekursionsbaum 38
Fast best case Rekursionsbaum T (n) =T ( 1 10 n)+t ( 9 10 n)+θ(n) 39
Randomisierter Quicksort Idee: Zerlegung um ein zufälliges Element 40
Randomisierter Quicksort Idee: Zerlegung um ein zufälliges Element Laufzeit unabhängig von Eingabe Keine Annahmen über Eingabe nötig Keine spezielle Eingabe führt zu Worst Case Worst Case tritt auf bei unglücklicher Folge von zufälligen Elementen 41
Analyse Analyse hier folgt Problemstellung 7-2 im Buch Anders als Analyse in Abschnitt 7.4.2 Natürlich mit gleichem Resultat Grundlagenmaterial in Abschnitt 5.2, 5.3, und Anhang C nachlesen 42
Analyse Indikatorfunktionen X k = 1 if Partition generates a k : n k 1 split 0 otherwise Erwartungswert E[X k ] = Pr{X k = 1} = 1/n Kosten T (0) + T (n 1) + Θ(n) if0:n 1split T (1) + T (n 2) + Θ(n) if 1 : n 2split T (n) = ( ). T (n 1) + T (0) + Θ(n) if n 1 : 0 split = P n 1 k=0 X k(t (k)+t (n k 1) + Θ(n)) 43
Erwartungswert E[T (n)] = E n 1 X Xk (T (k)+t (n k 1) + Θ(n)) k=0 44
Rekursionsgleichung Beweise E[T (n)] = 2 n n 1 X E[T (k)] + Θ(n) n k=2 E[T [ (n)] an lg n für Konstante a>0 Benutze n 1 X k lg k 1 2 n2 lg n 1 8 n2 k=2 2 8 45
Substitutionsmethode E[T (n)] = 2 n n 1 X n k=2 E[T (k)] + Θ(n) 46
Quicksort Zusammenfassung Einer der beliebtesten Sortieralgorithmen in der Praxis Häufig ca. zwei Mal schneller als Merge Sort Günstiges Verhalten mit Speicherhierarchien (Caches, virtueller Speicher) 47
Nächste Vorlesung Sortieren in linearer Zeit, Kapitel 8 48