Heapsort / 1 A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]

Transkript

1 Heapsort / 1 Heap: Ein Array heißt Heap, falls A [i] A [2i] und A[i] A [2i + 1] (für 2i n bzw. 2i + 1 n) gilt. Beispiel: A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]

2 Heapsort / 2 Darstellung eines Heaps als Baum. A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] Die Heapeigenschaft bedeutet, dass jeder Knoten einen mindestens so großen Wert hat wie seine Kinder.

3 Heapsort / 3 Heapsort: (1) Forme A in einen Heap um. (2) Forme den Heap in sortiertes Array um.

4 Heapsort / 4 Die Basis-Prozedur: Heapify Voraussetzung bei Aufruf von Heapify (m, i) Teilbäume unter den Kindern von A[i], (d.h. Teilbäume mit Wurzeln A[2i] und A [2i + 1]) im Teilarray A [1:m] sind Heaps. Aufgabe von Heapify(m, i) Teilbaum unter A[i] ist im Teilarray A [1:m] ein Heap.

5 Heapsort / 5 Heapify (m, i) Falls i > m Stop; sonst: Sei k > 0 so, dass A [k] = max {A[i], A[2i], A [2i+1]} (falls 2i > m: A[2i] = -, falls 2i + 1 > m: A[2i+1] =- ) falls A[k] = A[i] Stop; falls A[k] = A[2i]: Vertausche A[i] und A[2i]; Heapify (m, 2i); falls A[k] = A[2i+1]: Vertausche A[i] und A[2i+1] Heapify (m, 2i + 1). Korrektheit: Vergleiche: Vertauschungen: Gesamt: 2 (log (m) - log (i)) log (m) - log (i) 3 (log (m) - log (i))

6 Heapsort / 6 Algorithmus für Teil (2) Für m =n, n-1,..., 2: Vertausche A[1] und A[m] Heapify (m-1,1) # Operationen: Σ 2 m n (3 log (m) +1) 3 n log (n) + n

7 Heapsort / 7 Algorithmus für Teil (1) Für i = n/2, n/2-1,..., 1 Heapify (n,i) Invariante: Nach dem Aufruf von Heapify (n,i) bildet der Teilbaum mit Wurzel i einen Heap. # Operationen: Σ 1 i n 3 (log (n) - log (i)) n

8 Heapsort / 8 Satz: Heapsort benötigt im worst case höchstens 3 n log (n) n Operationen, davon ungefähr 2 n log(n) Vergleiche.

9 Mergesort / 1 Daten liegen nicht im Array, sondern in FILES vor. Einschränkung: Falls a i gelesen wurde, kostet es j - i Schritte um a i (j > i) zu lesen. Quicksort, Heapsort werden langsam!

10 Mergesort / 2 MergeSort (a 1,..., a n ) Falls n =1 Stop Falls n >1: MergeSort (a 1,..., a n/2 ) MergeSort (a n/2 +1,..., a n ) Mische (a 1,..., a n/2 ; a n/2 +1,..., a n ) # Vergleiche: T (1) = 0 n > 1: T(n) 2 T ( n / 2 ) + n - 1 Satz: MergeSort benötigt im worst case n log (n) - n + 1 Vergleiche (aber Speicherplatz 2n + 0 (1))

11 Untere Schranke / 1 Kann man mit o (n log (n)) vielen Vergleichen sortieren? Formales Rechenmodell: Vergleichsbaum Binärer Baum, Wurzel und innere Knoten enthalten Vergleiche "x i < x j? Bei Eingabe a 1,..., a n wählt Rechnung den linken/rechten Ast von x i < x j?, falls a i < a j / a i > a j ist. Baum sortiert (ist Sortierbaum), falls alle Eingaben, die den gleichen Weg zu einem Blatt folgen, den gleichen Ordnungstyp haben.

12 Untere Schranke / 2 Alle bisher vorgestellten Sortierverfahren lassen sich als Sortierbäume beschreiben. # Vergleiche: worst case: Tiefe des Baumes (d.h.: Länge eines längsten Weges im Baum) average case: 1 Σ (Länge des Weges Wurzel v ) # Blätter v Blatt

13 Untere Schranke / 3 Worst case: Die Tiefe jedes binären Baumes mit N Blättern ist mindestens log (N). worst case: Jeder Vergleichs-basierte Sortieralgorithmus macht im worst case mindestens log (n!) = n log (n) - Θ (n) Vergleiche.

14 Untere Schranke / 4 Average Case: Die durchschnittliche Tiefe eines jeden binären Baumes mit N Blättern ist mindestens log (N) -1. average case: Jeder Vergleichs-basierte Sortieralgorithmus macht im Durchschnitt mindestens log (n!) - 1 = n log (n) - Θ (n) Vergleiche. Heapsort und Mergesort sind im worst case und im average case bis auf konstante Faktoren optimal. Quicksort ist im average case bis auf konstante Faktoren optimal.

15 Sortieren ohne Vergleichen / 1 Bucket Sort: Einschränkung: a 1,..., a n {1,..., M} Nutze Array L [1:M] von linearen Listen. BucketSort (Eingabe a 1,..., a n {1,..., M}) zu Beginn: L[i] ist leer für alle i = 1,..., M. (1) Für j = 1,..., n: - Hänge a j an Liste L [a j ] an. (2) Hänge die Listen L[1],..., L[M] zur Liste L hintereinander. (3) Durchlaufe L von vorne nach hinten und gebe die gelesenen Werte aus. Zeit: O (n + M) Platz: O (n + M)

16 Sortieren ohne Vergleichen / 2 Beobachtung: Bucket Sort sortiert stabil, d.h. für a i = a j steht a i vor a j, falls i < j gilt. Ziel: Sortiere Worte a i = (a i1,..., a ik ), i = 1,..., n, a ji {1,..., m}, lexikographisch.

17 Sortieren ohne Vergleichen / 3 VerallgemeinerterBucketSort (Eingabe a 1,..., a n {1,..., m} k, a i = (a i1,..., a ik )) { Für r = k, k - 1,..., 1: Sortiere a 1,..., a n gemäß der Schlüssel a 1r,..., a nr mit BucketSort. Zeit, um n Worte aus {1,..., m} k lexikographisch zu sortieren: O ((n + m) k) ;Platz: 0 (n + m + k n) Zeit um n Zahlen aus {0,..., n k -1}zu sortieren: 0 (k n) für k = o(log (n)) besser als die untere Schranke!!!