Datenstrukturen & Algorithmen

Transkript

1 Datenstrukturen & Algorithmen Matthias Zwicker Universität Bern Frühling 2010

2 Übersicht Sortieralgorithmen Einleitung Heapsort Quicksort 2

3 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

4 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

5 Übersicht Sortieralgorithmen Einleitung Heapsort Quicksort 5

6 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: Ausgabe:

7 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

8 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] Feld A Darstellung als Binärbaum 8

9 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] Feld A Darstellung als Binärbaum 9

10 Heap Eigenschaft Max-Heap A[Vater(i)]>=A[i] Min-Heap A[Vater(i)]<=A[i] 1 heap-grösse[a] länge[a] xx Feld A Darstellung als Binärbaum Max-Heap 10

11 Aufrechterhaltung der Heapeigenschaft Ausgangslage Gegeben Index i Bäume ausgehend von Left(i) und Right(i) sind Heaps Knoten i verletzt Heapeigenschaft 11

12 Aufrechterhaltung der Heapeigenschaft Max-Heapify(A,2)

13 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

14 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

15 Heap Konstruktion

16 Heap Konstruktion

17 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

18 Heap Sort

19 Heap Sort

20 Heap Sort

21 Aufwand Heap Konstruktion Aufrechterhaltung der Heap Eigenschaft Total 21

22 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

23 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

24 Implementation mit Heaps 24

25 Implementation mit Heaps 25

26 Übersicht Sortieralgorithmen Einleitung Heapsort Quicksort 26

27 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

28 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

29 Zerlegung des Felds 29

30 Zerlegung des Felds Schleifeninvariante 30

31 Schleifeninvariante p i j r >x x x >x p i j r x x x >x 31

32 Beispiel

33 Beispiel p i j r

34 Quicksort Aufruf Quicksort(A,1,länge[A]) 34

35 Analyse Annahme: keine doppelten Elemente Alle Elemente sind verschieden 35

36 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

37 Worst case Rekursionsbaum T (n) = T (0) + T (n 1) + Θ(n) 37

38 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 ( n) + T ( 10 n) + Θ(n) Rekursionsbaum 38

39 Fast best case Rekursionsbaum T (n) =T ( 1 10 n)+t ( 9 10 n)+θ(n) 39

40 Randomisierter Quicksort Idee: Zerlegung um ein zufälliges Element 40

41 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

42 Analyse Analyse hier folgt Problemstellung 7-2 im Buch Anders als Analyse in Abschnitt Natürlich mit gleichem Resultat Grundlagenmaterial in Abschnitt 5.2, 5.3, und Anhang C nachlesen 42

43 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

44 Erwartungswert E[T (n)] = E n 1 X Xk (T (k)+t (n k 1) + Θ(n)) k=0 44

45 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=

46 Substitutionsmethode E[T (n)] = 2 n n 1 X n k=2 E[T (k)] + Θ(n) 46

47 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

48 Nächste Vorlesung Sortieren in linearer Zeit, Kapitel 8 48