Kapitel 6: Suchbäume und weitere Sortierverfahren 6.1   Binäre Bäume Die Klasse BinTree mit Traversierungsmethoden 6.2   Suchbäume 6.2.1   AVL Bäume 6.3   HeapSort und BucketSort 6.3.1   HeapSort 6.3.2   BucketSort

6.3 BucketSort Alle Sortierverfahren bisher basieren auf: Vergleiche je zweier Schlüssel. Allgemeine untere Schranke für den Aufwand: O(n log n). Für spezielle Schlüsselmengen: Sortieren möglich ohne Vergleiche und effizienter!

Idee: verwende die Schlüssel zur Berechnung der Speicheradresse in der sortierten Folge (wie beim Hashing). Beispiel: Menge von n Datenobjekten {s0, ... , sn-1} mit Schlüsselwerten 0, ..., n-1, gegeben als Array S. Sortieralgorithmus: for(int i = 0, i < n, i++) T[S[i].key] = S[i]; Aufwand: O(n).

Menge von n Datenobjekten {s0,. , sn-1} mit Schlüsselwerten 0, Menge von n Datenobjekten {s0, ... , sn-1} mit Schlüsselwerten 0, ..., m-1, gegeben als Array S. Duplikate zugelassen. Erinnerung: CountingSort (Aufgabe 19) {int C[] = new int[k]; for(int j = 0, j < m, j++) C[j] = 0; for(int i = 0, i < n, i++) C[S[i].key]++; for(int j = 0, j < m, j++) C[j] = C[j]+C[j-1]; for(int i = n-1, i >= 0, i++) { T[C[S[i].key]-1] := S[i]; C[S[i].key]--; } } Aufwand: O(n+m).

BucketSort Menge von n Datenobjekten {s0, ... , s n-1} mit Schlüsselwerten 0, ..., m-1, gegeben als Array S. Duplikate zugelassen. void BucketSort(S) { int i; int j; for(j=0; j<m; j++) B[j] = null; for(i=0; i<n; i++) insert(S[i], B[S[i].key()] ); for(j=0; j<m; j++) output(B[j]); } Aufwand: O(n+m).

RadixSort Menge von n Datenobjekten {s0, ... , sn-1} mit Schlüsselwerten 0, ..., nk -1, gegeben als Array S. Duplikate zugelassen. Bucketsort dafür: O(n + nk). Verbesserung (RadixSort): schreibe die Schlüssel zur Basis n. Man erhält Zahlen mit k Ziffern. Sortiere der Reihe nach (z.B. von hinten mittels mod und div) nach jeder Ziffer mit BucketSort. Aufwand: O(k•n).

Beispiel zu RadixSort: n=10, k=2. Zu sortierende Folge: 64, 17, 3, 99, 79, 78, 19, 13, 67, 34. 1. Schritt: Einfügen in Buckets nach letzter Ziffer: und (von oben) ausgeben: 3, 13, 64, 34, 17, 67, 78, 99, 79, 19 1 2 3 4 5 6 7 8 9 13 64 34 17 67 78 99 79 19

Fortsetzung RadixSort 2. Schritt: im 1. Schritt ausgegebene Folge 3, 13, 64, 34, 17, 67, 78, 99, 79, 19 einfügen in Buckets nach vorletzter Ziffer: und ausgeben: 3, 13, 17, 19, 34, 64, 67, 78, 79, 99. 1 2 3 4 5 6 7 8 9 13 17 19 34 64 67 78 79 99

Verallgemeinerung: Ziffern können an den verschiedenen Positionen auch in verschiedenen Wertebereichen liegen. Beispiel: Datum=(Jahr, Monat, Tag) ( [0..9999], [1..12], [1..31] ) BucketSort nach Jahr, nach Monat und nach Tag.

Kapitel 7: Ausgewählte Algorithmen 7.1   Externes Suchen

7.1 Externes Suchen Bisherige Algorithmen: geeignet, wenn alle Daten im Hauptspeicher. Große Datenmengen: oft auf externen Speichermedien, z.B. Festplatte. Zugriff: immer gleich auf einen ganzen Block (eine Seite) von Daten, z.B: 4096 Bytes. Effizienz: Zahl der Seitenzugriffe klein halten!

Für externes Suchen: Variante von Suchbäumen mit: Knoten = Seite Vielwegsuchbäume!

Definition (Vielweg-Suchbaum) Der leere Baum ist ein Vielweg-Suchbaum mit der Schlüsselmenge {}. Seien T0, ..., Tn Vielweg-Suchbäume mit Schlüsseln aus einer gemeinsamen Schlüsselmenge S, und sei k1,...,kn eine Folge von Schlüsseln mit k1 < ...< kn. Dann ist die Folge T0 k1 T1 k2 T2 k3 .... kn Tn ein Vielweg-Suchbaum genau dann, wenn: für alle Schlüssel x aus T0 gilt: x < k1 für i=1,...,n-1, für alle Schlüssel x in Ti gilt: ki < x < ki+1, für alle Schlüssel x aus Tn gilt: kn < x .

B-Baum Definition 7.1.2 Ein B-Baum der Ordnung m ist ein Vielweg-Suchbaum mit folgenden Eigenschaften 1  #(Schlüssel in Wurzel)  2m und m  #(Schlüssel in Knoten)  2m für alle anderen Knoten. Alle Pfade von der Wurzel zu einem Blatt sind gleichlang. Jeder innere Knoten mit s Schlüsseln hat genau s+1 Söhne.

Beispiel: Ein B-Baum der Ordnung 2:

Abschätzungen zu B-Bäumen Ein minimal gefüllter B-Baum der Ordnung m und Höhe h: Knotenzahl im linken wie im rechten Teilbaum 1 + (m+1) + (m+1)2 + .... + (m+1)h-1 =  ( (m+1)h – 1) / m. Die Wurzel hat einen Schlüssel, alle anderen Knoten haben m Schlüssel. Insgesamt: Schlüsselzahl n in einem B-Baum der Höhe h: n  2 (m+1)h – 1 Also gilt für jeden B-Baum der Höhe h mit n Schlüsseln: h  logm+1 ((n+1)/2) .

Beispiel Also gilt für jeden B-Baum der Höhe h mit n Schlüsseln: h  logm+1 ((n+1)/2). Beispiel: Bei Seitengröße: 1 KByte und jeder Eintrag nebst Zeiger: 8 Byte, kann m=63 gewählt werden, und bei einer Datenmenge von n= 1000 000 folgt      h  log 64 500 000.5 < 4 und damit hmax = 3.

7.1 Externes Suchen Definition 7.1.2 Ein B-Baum der Ordnung m ist ein Vielweg-Suchbaum mit folgenden Eigenschaften 1  #(Schlüssel in Wurzel)  2m und m  #(Schlüssel in Knoten)  2m für alle anderen Knoten. Alle Pfade von der Wurzel zu einem Blatt sind gleichlang. Jeder innere Knoten mit s Schlüsseln hat genau s+1 Söhne.

Beispiel: Ein B-Baum der Ordnung 2:

Abschätzungen zu B-Bäumen Ein minimal gefüllter B-Baum der Ordnung m und Höhe h: Knotenzahl im linken wie im rechten Teilbaum 1 + (m+1) + (m+1)2 + .... + (m+1)h-1 =  ( (m+1)h – 1) / m. Die Wurzel hat einen Schlüssel, alle anderen Knoten haben m Schlüssel. Insgesamt: Schlüsselzahl n in einem B-Baum der Höhe h: n  2 (m+1)h – 1 Also gilt für jeden B-Baum der Höhe h mit n Schlüsseln: h  logm+1 ((n+1)/2) .

Beispiel Also gilt für jeden B-Baum der Höhe h mit n Schlüsseln: h  logm+1 ((n+1)/2). Beispiel: Bei Seitengröße: 1 KByte und jeder Eintrag nebst Zeiger: 8 Byte, kann m=63 gewählt werden, und bei einer Datenmenge von n= 1000 000 folgt      h  log 64 500 000.5 < 4 und damit hmax = 3.

Algorithmen zum Einfügen und Löschen von Schlüsseln in B-Bäumen Algorithmus insert (root, x) //füge Schlüssel x in den Baum mit Wurzelknoten root ein suche nach x im Baum mit Wurzel root; wenn x nicht gefunden { sei p Blatt, an dem die Suche endete; füge x an der richtigen Position ein; wenn p nun 2m+1 Schlüssel {overflow(p)} }

Algorithmus Split (1) Algorithmus overflow (p) = split (p) Algorithmus split (p) Erster Fall: p hat einen Vater q. Zerlege den übervollen Knoten. Der mittlere Schlüssel wandert in den Vater. Anmerkung: das Splitting muss evtl. bis zur Wurzel wiederholt werden.

Algorithmus Split (2) Algorithmus split (p) Zweiter Fall: p ist die Wurzel. Zerlege den übervollen Knoten. Eröffne eine neue Ebene nach oben mit einer neuen Wurzel mit dem mittleren Schlüssel.

Algorithmus delete (root ,x) //entferne Schlüssel x aus dem Baum mit Wurzel root suche nach x im Baum mit Wurzel root; wenn x gefunden { wenn x in einem inneren Knoten liegt { vertausche x mit dem nächstgrößeren Schlüssel x' im Baum // wenn x in einem inneren Knoten liegt, gibt // es einen nächstgrößeren Schlüssel // im Baum, und dieser liegt in einem Blatt } sei p das Blatt, das x enthält; lösche x aus p; wenn p nicht die wurzel ist { wenn p m-1 Schlüssel hat {underflow (p)} } }

Algorithmus underflow (p) // behandle die Unterläufe des Knoten p wenn p einen Nachbarknoten hat mit s>m Knoten { balance (p,p') } anderenfalls // da p nicht die Wurzel sein kann, muss p Nachbarn mit m Schlüsseln haben { sei p' Nachbar mit m Schlüsseln; merge (p,p')}

Algorithmus balance (p, p') // balanciere Knoten p mit seinem Nachbarknoten p' (s > m , r = (m+s)/2 -m )

Algorithmus merge (p,p') // verschmelze Knoten p mit seinem Nachbarknoten Führe die folgende Operation durch: Anschließend: wenn ( q <>  Wurzel) und (q hat m-1 Schlüssel) underflow (q) anderenfalls (wenn (q= Wurzel) und (q leer)) {gib q frei und lasse root auf p^ zeigen}

Rekursion Wenn es bei underflow zu merge kommt, muss evtl. underflow eine Ebene höher wiederholt werden. Dies kann sich bis zur Wurzel fortsetzen.

Beispiel: B-Baum der Ordnung 2

Aufwand Sei m die Ordnung des B-Baums, n die Zahl der Schlüssel. Aufwand für Suchen, Einfügen, Entfernen: O(h) = O(logm+1 ((n+1)/2) ) = O(logm+1(n)).

Anmerkung: B-Bäume auch als interne Speicherstruktur zu gebrauchen: Besonders: B-Bäume der Ordnung 1 (dann nur 1 oder 2 Schlüssel pro Knoten – keine aufwändige Suche innerhalb von Knoten). Aufwand für Suchen, Einfügen, Löschen: O(log n).

Anmerkung: Speicherplatzausnutzung: über 50% Grund: die Bedingung: 1/2•k  #(Schlüssel in Knoten)  k Für Knoten  Wurzel (k=2m)

2/3•k  #(Schlüssel in Knoten)  k Noch höhere Speicherplatzausnutzung möglich, z.B. über 66% mit Bedingung: 2/3•k  #(Schlüssel in Knoten)  k für alle Knoten mit Ausnahme der Wurzel und ihrer Kinder. Erreichbar durch 1) modifiziertes Balancieren auch beim Einfügen und 2) split erst, wenn zwei Nachbarn ganz voll. Nachteil: Häufigere Reorganisation beim Einfügen und Löschen notwendig.

7.2 Externes Sortieren Problem: Sortieren großer Datenmengen, wie beim Externen Suchen gespeichert in Blöcken (Seiten). Effizienz: Zahl der Seitenzugriffe klein halten! Strategie: Sortieralgorithmus, der Daten sequentiell verarbeitet (kein häufiges Wechseln der Seiten): MergeSort!

Beginn: n Datensätze in einem File g1, unterteilt in Seiten der Größe b: Seite 1: s1,…,sb Seite 2: sb+1,…s2b … Seite k: s(k-1)b+1 ,…,sn ( k = [n/b]+ ) Bei sequentieller Verarbeitung: nur k Seitenzugriffe statt n.

Varianten von MergeSort für Externes Sortieren MergeSort: Divide-and-Conquer-Algorithmus Für Externes Sortieren: ohne Divide-Schritt, nur noch Merge. Definition: Lauf := geordnete Teilfolge innerhalb eines Files. Strategie: durch Merge immer größere Läufe erzeugen, bis alles sortiert.

Algorithmus 1. Schritt: Erzeuge aus der Folge im Eingabefile g1 „Anfangsläufe“ und verteile sie auf zwei Files f1 und f2, gleich viele (1) auf jeden. (hierzu gibt es verschiedene Strategien, später). Nun: verwende vier Files f1, f2, g1, g2.

2. Schritt (Hauptschritt): Solange Zahl der Läufe > 1 wiederhole: { Mische je zwei Läufe von f1 und f2 zu einem doppelt so langen Lauf abwechselnd nach g1 und g2, bis keine Läufe auf f1 und f2 mehr übrig. Mische je zwei Läufe von g1 und g2 zu einem doppelt so langen Lauf abwechselnd nach f1 und f2, bis keine Läufe auf g1 und g2 mehr übrig. } Jede Schleife = zwei Phasen