Exponentielle Suche

Algorithmen & Datenstrukturen

3. Suchen

Exponentielle Suche

Gesucht wird ein Element mit Schl¨ussel k. Die exponentielle Suche eignet sich zum Suchen in nach den Schl¨usselwerten sortierten Feldern, deren L¨ange nicht bekannt ist.

Bestimme in exponentiell wachsenden Schritten einen Bereich, in dem der Schl¨ussel liegen muss (erster Index ist 1):

i = 1;

while (k > a[i].key) i = 2*i;

Danach gilt: a[i/2].key < k ≤ a[i].key

Dieser Bereich wird mittels bin¨arer Suche durchsucht.

Exponentielle Suche: Beispiel

Wir suchen den Schl¨ussel k = 42 im folgenden Feld:

1 3 4 7 9 12 13 18 27 28 39 62 98 . . .

a: 2 11 42

(1) bestimme den Bereich, in dem k liegen muss:

1 3 4 7 9 12 13 18 27 28 39 42 62 98 . . . a:

i = 1 2 4 8 16

2 11

(2) bin¨are Suche im Bereich a[i/2+1] ... a[i]:

13 18 27 28 39 42 62 98 . . . . . .

mid = (9 + 16) / 2 = 12

13 18 27 28 39 42 62 98 . . . . . .

mid = (13 + 16) / 2 = 14

Exponentielle Suche: Laufzeit

Voraussetzung: Werte sind paarweise verschieden (dies ist z.B. dann gegeben, wenn Schl¨usselwerte gesucht werden, Telefonnummer, Ma- trikelnummer, Personalnummer, usw.)

⇒ Schl¨ussel wachsen mindestens so stark wie die Indices

⇒ die Bereichsbestimmung erfolgt in log₂(k) Schritten

⇒ der zu durchsuchende Bereich hat h¨ochstens k Zahlen und kann in Zeit log₂(k) durchsucht werden

insgesamt ergibt sich also eine Laufzeit von Θ(log(k))

Falls die Folge auch gleiche Werte enthalten darf, ist keine Laufzeit- absch¨atzung m¨oglich.

Lineare Suche und bin¨ are Suche

In Kapitel 1.2 haben wir ausf¨uhrlich die

• lineare (Elemente nacheinander lesen) und die

• bin¨are (rekursive, immer mit dem mittleren Element vergleichen)

Suche besprochen und die Komplexit¨aten im besten, mittleren und schlechtesten Fall berechnet. Es ergab sich

• linear: O_best = O(1), O_avg = O(n), O_worst = O(n)

• bin¨are: O_best = O(1), O_avg = O(log(n)), O_worst = O(log(n))

Interpolations-Suche

Idee: Sch¨atze die Position des Elements mit Schl¨ussel k.

Beispiel: Im Telefonbuch steht der Name Zimmermann weit hinten, wo- hingegen Brockmann eher am Anfang steht.

Sei l linke Grenze, r rechte Grenze des Suchbereichs:

• bei der bin¨aren Suche wurde der Index des n¨achsten zu inspizie- renden Elements bestimmt als

m = l + 1

2 · (r − l).

• bei der Interpolationssuche inspiziere als n¨achstes das Element auf Position

m = l + k − a[l].key

a[r].key − a[l].key · (r − l).

Interpolations-Suche: Beispiel (a)

gesucht: k = 42

1 3 3 4 7 9 12 12 13 18 27 28 39 62 98

a: 42

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

l = 0 r = 15

m = 0 + (42 − 1) / (98 − 1) * (15 − 0) = 6

1 3 3 4 7 9 12 12 13 18 27 28 39 62 98

a: 42

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

r = 15 l = 7

m = 7 + (42 − 12) / (98 − 12) * (15 − 7) = 9

Interpolations-Suche: Beispiel (b)

gesucht: k = 42

1 3 3 4 7 9 12 12 13 18 27 28 39 62 98

a: 42

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

r = 15 l = 10

m = 10 + (42 − 27) / (98 − 27) * (15 − 10) = 11

1 3 3 4 7 9 12 12 13 18 27 28 39 62 98

a: 42

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

r = 15 m = 12 + (42 − 39) / (98 − 39) * (15 − 12) = 12

l = 12

Interpolations-Suche: Beispiel (c)

gesucht: k = 42

1 3 3 4 7 9 12 12 13 18 27 28 39 62 98

a: 42

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

m = 13 + (42 − 42) / (98 − 42) * (15 − 13) = 13 r = 15 l = 13

Im worst-case hat das Verfahren eine lineare Laufzeit, also Θ(n) bei n Schl¨usselwerten.

Beispiel: k = 10 und F = 1,2,3,4,5,6,7,8,9,10,1000

Interpolations-Suche: Laufzeit

Im Mittel werden log(log(n)) + 1 Schl¨usselvergleiche ausgef¨uhrt [1], aber dieser Vorteil geht durch die auszuf¨uhrenden arithmetischen Ope- rationen oft verloren.

Im best-case wird jedes Element sofort gefunden, also Θ(1) bei n Schl¨usselwerten. Beispiel mit 9 gleichverteilten Elementen

F = 10,12,14,16,18,20,22,24,26 m = 0 + k − a[0].key

a[8].key − a[0].key · (8 − 0) = k − 10

26 − 10 · 8 = k − 10 2

[1] A.C. Yao and F.F. Yao: The complexity of searching an orde- red random table. Proceedings of the Symposium on Foundations of Computer Science, 1976

Hash-Verfahren (1)

Schl¨usselsuche durch Berechnung der Array-Indices!

Idee:

• bei einer Menge von Werten K ⊆ {0,1, . . . , m − 1} = U

• verwende ein Array A der L¨ange m mit Indices von 0 bis m − 1

• und speichere die Schl¨ussel wie folgt:

A[k] =

( x falls x.key ∈ K und x.key = k nil sonst

⇒ suchen, einf¨ugen und l¨oschen in Θ(1) Schritten Problem: Wertebereich kann sehr groß sein

8-stellige Namen → mehr als 208.000.000.000 Werte

Hash-Verfahren (2)

L¨osung: verwende eine Hash-Funktion h, um den Wertebereich U, speziell die Menge der Schl¨usselwerte K, auf die Zahlen 0, . . . , l − 1 abzubilden, also h : U → {0, . . . , l − 1}.

U K

Hash-Funktion i.Allg. nicht injektiv: verschiedene Schl¨ussel werden auf dieselbe Hash-Adresse abgebildet → Kollision

Hash-Funktion wird zum Platzieren und Suchen verwendet, muss ein- fach/effizient zu berechnen sein

Hash-Verfahren (3)

Schl¨ussel, die nicht als Zahlen interpretiert werden k¨onnen, m¨ussen vorher geeignet umgerechnet werden.

Beispiel: 5 Zeichenketten der L¨ange 3

• Die ASCII-Darstellung wird als Bin¨arzahl interpretiert.

• Interpretiere die Bin¨arzahlen als Ziffern einer Zahl zur Basis 256, z.B. i2 = 0 105 50 = 105·256 + 50 = 26930

Input k₁ k₂ k₃ k h(k) = k mod 11 h(k) = k mod 13

i 0 0 105 105 6 1

i2 0 105 50 26930 2 7

ii 0 105 105 26985 2 10

iii 105 105 105 6908265 1 0

i_2 105 95 50 6905650 4 11

Hash-Verfahren (4)

Hash-Verfahren muss zwei Forderungen gen¨ugen:

1. es sollen m¨oglichst wenige Kollisionen auftreten

2. Adress-Kollisionen m¨ussen effizient aufgel¨ost werden Wahl der Hash-Funktion:

• soll die zu speichernden Datens¨atze m¨oglichst gleichm¨aßig auf den Speicherbereich verteilen, um Adress-Kollisionen zu vermeiden

• H¨aufungen in der Schl¨usselverteilung sollen sich nicht auf die Ver- teilung der Adressen auswirken

• es gilt: wenn eine Hash-Funktion ^qπn/2 Schl¨ussel auf eine Tabelle der Gr¨oße n abbildet, dann gibt es meist eine Kollision (f¨ur n = 365 ist ^qπn/2 ≈ 23, 23 Personen auf deren Geburtstage abgebildet)

Hash-Funktion: Division-Rest-Methode

Methode: Der Schl¨ussel wird ganzzahlig durch die L¨ange der Hash- Tabelle dividiert. Der Rest wird als Index verwendet:

h(k) = k mod m zu beachten:

• m soll keinen kleinen Teiler haben!

• m soll keine Potenz der Basis des Zahlensystems sein! Beispiel: f¨ur m = 2^r h¨angt der Hash-Wert nur von den letzten r Bits ab

⇒ w¨ahle m als Primzahl, die nicht nah an einer Potenz der Basis des Zahlensystems liegt. Beispiel: m = 761, aber nicht: m = 509 (nah an 2⁹) oder m = 997 (nah an 10³)

Hash-Funktion: Multiplikative Methode

Sei m = 2^r eine Zweierpotenz, d.h. es k¨onnen die Werte 0 . . . ,2^r − 1 angenommen werden. Bei einer Wortgr¨oße w w¨ahle eine Zahl a so, dass 2^w−1 < a < 2^w ist, und w¨ahle f¨ur h(k)

h(k) = (a · k mod 2^w) >> (w − r) Anmerkungen:

• W¨ahle a nicht zu nah an 2^w bzw. 2^w−1

• Modulo-Operation und Rechts-Shift ist schnell

• gute Ergebnisse f¨ur a ≈ ^√5₂⁻¹ · 2^w (goldener Schnitt)

Beispiel: F¨ur w = 8, r = 3, a = 191 und k = 23 erhalten wir

1 0 0 0 1 0 0 1 0 1 0 0 1 1 1 1 1 1 1 0 1

1 1 1 0 1 0 0 0

*

191

23

4393

Hash-Verfahren: Verkettung der ¨ Uberl¨ aufer

Probleme treten auf

• beim Einf¨ugen, wenn die be- rechnete Hash-Adresse nicht leer ist

• bei der Suche, wenn der be- rechnete Platz ein anderes Element enth¨alt

32

7 %

61

T: i

h(61) = h(32) = h(7) = i

Kollisionsaufl¨osung: Die ¨Uberl¨aufer k¨onnen in einer linearen Liste verkettet werden, die an den Hash-Tabelleneintrag angeh¨angt wird.

Verkettung der ¨ Uberl¨ aufer: Bewertung (1)

Die durchschnittliche Anzahl der Eintr¨age in h(k) ist n/m, wenn n Eintr¨age durch die Hash-Funktion gleichm¨aßig auf m Listen verteilt werden. Belegungsfaktor: α = _mⁿ

Mittlere Laufzeit bei erfolgreicher Suche:

• beim Einf¨ugen des j-ten Schl¨ussels ist die durchschnittliche Lis- tenl¨ange ^j−_m¹

• bei einer sp¨ateren Suche nach dem j-ten Schl¨ussel betrachten wir also im Durchschnitt 1 + ^j−_m¹ Eintr¨age, wenn stets am Listenende eingef¨ugt wird und keine Elemente gel¨oscht wurden

C = 1 n

n X

j=1

1 + j − 1 m

= 1 + n − 1

2m ≈ 1 + n 2m

Verkettung der ¨ Uberl¨ aufer: Bewertung (2)

in der Regel gilt n ∈ O(m) (die Gr¨oße der Hash-Tabelle ist ungef¨ahr so groß wie die Anzahl der Datens¨atze)

⇒ α = n

m = O(m)

m ∈ O(1)

zum Vergleich: bin¨are Suche hat Laufzeit Θ(log(n)) plus Aufwand Θ(n log(n)) zum Sortieren der Datens¨atze

Problem: verkettete Listen sind umst¨andlich zu Programmieren und dynamische Speicheranforderung ist teuer.

L¨osung: speichere alle Datens¨atze innerhalb eines Arrays

Offene Hash-Verfahren (1)

Idee: Speichere die ¨Uberl¨aufer in der Hash-Tabelle, nicht in zus¨atzli- chen Listen

• ist die Hash-Adresse h(k) belegt, so wird systematisch eine Aus- weichposition gesucht

• die Folge der zu betrachtenden Speicherpl¨atze f¨ur einen Schl¨ussel nennt man Sondierungsfolge

• die Hash-Funktion h¨angt vom Schl¨ussel und von der Anzahl durch- gef¨uhrter Platzierungsversuche ab:

h : U × {0, . . . , m − 1} → {0, . . . , m − 1}

• die Sondierungsfolge muss eine Permutation der Zahlen 0, . . . , m−1 sein, damit alle Eintr¨age der Hash-Tabelle genutzt werden k¨onnen

Offene Hash-Verfahren (2)

Anmerkungen:

• beim Einf¨ugen und Suchen wird dieselbe Sondierungsfolge durch- laufen

• beim L¨oschen wird der Datensatz nicht gel¨oscht, sondern nur als gel¨oscht markiert (der Wert wird ggf. bei sp¨aterem Einf¨ugen ¨uber- schrieben)

• je voller die Tabelle wird, umso schwieriger wird das Einf¨ugen neuer Schl¨ussel

Lineares Sondieren

Zu einer gegebenen Hash-Funktion h^′(k) sei

h(k, i) = (h^′(k) + i) mod m.

i ist die Anzahl der Kollisionen f¨ur einen Key.

Beispiel: betrachte das Einf¨ugen der Schl¨ussel 12,55,5,15,2,47

f¨ur m = 7 mit h^′(k) = k mod 7 und

h(k, i) = (k mod 7 + i) mod 7 = (k + i) mod 7

12 55 5 15

2

5 15 12 55

12

5 15 2 55

2 mod 7 = 2 15 mod 7 = 1

1 2 3 4

0 5 6

0 1 2 3 4 5 6

12 12 12

55 55 5

12 mod 7 = 5

5 mod 7 = 5 55 mod 7 = 6 1.

2.

3.

4.

5.

6. 47

47 mod 7 = 5

Quadratisches Sondieren (1)

Zu einer gegebenen Hash-Funktion h^′(k) sei

h(k, i) = (h^′(k) + (−1)ⁱ · ⌈i/2⌉²) mod m.

⌈ ⌉ bedeutet aufrunden, z.B. ⌈0.5⌉ = 1

Ohne Beweis: Wenn m eine Primzahl der Form 4i + 3 ist, werden alle m¨oglichen Schl¨ussel erreicht.

Die Reihenfolge der Durchl¨aufe ist h(k, 0) = h^′(k) mod m

h(k, 1) = (h^′(k) + (−1)¹ · ⌈1/2⌉²) mod m = (h^′(k) − 1) mod m h(k, 2) = (h^′(k) + (−1)² · ⌈2/2⌉²) mod m = (h^′(k) + 1) mod m h(k, 3) = (h^′(k) + (−1)³ · ⌈3/2⌉²) mod m = (h^′(k) − 4) mod m

Quadratisches Sondieren (2)

In der Literatur finden sie unterschiedliche Vorzeichen bei den Sondie- rungsfunktionen

Beispiel: betrachte das Einf¨ugen der Schl¨ussel 12,55,5,15,2,47

f¨ur m = 7 mit h(k, i) = (k + (−1)ⁱ · ⌈i/2⌉²) mod 7

12 55 15

2 12 55

15

12

15 2 47 55

47 mod 7 = 5 2 mod 7 = 2 15 mod 7 = 1

1 2 3 4

0 5 6

0 1 2 3 4 5 6

12 12 12

55 55

12 mod 7 = 5

5 mod 7 = 5 55 mod 7 = 6 1.

2.

3.

4.

5.

5 6.

5 5 5

47 → 5 → 4 → 6 → 1 → 2 → (5 − 9) mod 7 = 3

Double Hashing (1)

Zu zwei gegebenen Hash-Funktionen h₁(k) und h₂(k) sei h(k, i) = (h₁(k) + i · h₂(k)) mod m.

F¨ur die Form h(k, i) = (k+i·(1+k mod m₂)) mod m₁ und m₁−2 = m₂ werden alle m¨oglichen Schl¨usselwerte erreicht.

Beispiel: betrachte die Hash-Funktionen m = 7, h₁(k) = k mod 7 und h₂ = 1 + k mod 5:

h(k, i) = (k + i · (1 + k mod 5)) mod 7. Die Reihenfolge der Durchl¨aufe ist

h(k, 0) = (k + 0 · (1 + k mod 5)) mod 7 h(k, 1) = (k + 1 · (1 + k mod 5)) mod 7 h(k, 2) = (k + 2 · (1 + k mod 5)) mod 7

Double Hashing (2)

Beispiel: betrachte das Einf¨ugen der Schl¨ussel 12,55,5,15,2,47

und

h(k, i) = (k + i · (1 + k mod 5)) mod 7.

12 55 15

2 12 55

15

12

15 2 55

2 mod 7 = 2 15 mod 7 = 1

1 2 3 4

0 5 6

0 1 2 3 4 5 6

12 12 12

55 55

12 mod 7 = 5

5 mod 7 = 5 55 mod 7 = 6 1.

2.

3.

4.

5.

5 6.

5 5

5 47

47 mod 7 = 5

5 → 5 → 6 → 0 47 → 5 → 1 → 4

Alle Verfahren lassen sich noch leicht beschleunigen, wenn h¨aufiger gesucht als eingef¨ugt wird.

Suchb¨ aume (1)

Eine Alternative f¨ur Suchprobleme sind Suchb¨aume (siehe Kapitel 1)

• Voraussetzung f¨ur die schnelle Suche: der Suchbaum muss aus- geglichen sein, d.h. die Bl¨atter unterscheiden sich in ihrer Stufe h¨ochstens um 1.

• Die Anzahl der Suchschritte in einem ausgeglichenen Suchbaum ist proportional zum Logarithmus der Datenzahl.

• Die Anzahl der Knoten in einem bin¨aren Baum der H¨ohe T (Wurzel hat H¨ohe 0) ist maximal

k =

T−1 X

i=0

2ⁱ = 2^T − 1

Suchb¨ aume (2)

• Umgekehrt braucht ein bin¨arer Baum, wenn er k Knoten aufneh- men soll, eine H¨ohe von mindestens T = ⌈log₂(k+ 1)⌉ (aufrunden)

• Beispiel:

T = 20 ↔ k_max = 2⁽²⁰⁾ − 1 =1048575 Knoten

Jeder Knoten wird nach maximal 20 Schritten erreicht.

• Sogenannte optimale Suchb¨aume ber¨ucksichtigen beim Aufbau eine Wahrscheinlichkeit, mit der ein Schl¨ussel gesucht wird, und werden mittels dynamischer Programmierung aufgebaut.

Operationen f¨ ur B¨ aume (1)

Suchen eines Elements

Das Suchen eines Elements setzt eine Ordnung voraus.

• Ist der Key des Elements gleich dem Key des Knotens, dann ist das Element gefunden.

• Ist der Key des Elements kleiner (gr¨oßer) als der Key des Knotens, suche im linken (rechten) Teilbaum.

• Ist der (Teil-)Baum leer, ist das Element nicht vorhanden.

Operationen f¨ ur B¨ aume (2)

Einf¨ugen eines neuen Knotens in einen Suchbaum

• Ist der Baum leer, dann wird das neue Element die Wurzel.

• Falls sortiertes Einf¨ugen, f¨uhre rekursiv aus: Ist der Key des Ele- ments kleiner (gr¨oßer) als der Key des Knotens, f¨uge in den linken (rechten) Teilbaum ein.

• Erzeuge neuen Knoten an dem Blatt, bei dem einf¨ugt wird, schrei- be die Daten in den Knoten und setzte rechten bzw. linken Zeiger von der Einf¨ugestelle auf den neuen Knoten.

Operationen f¨ ur B¨ aume (3)

Der Aufbau eines Baums h¨angt von der Reihenfolge des Einf¨ugens ab.

30 10

05

20

Einzufügender Knoten 05

Reihenfolge 20 10 30 15 35 25

15 25 35

Einzufügender Knoten 05

Reihenfolge 35 30 25 20 15 10

10

15

20

25

30

35

05

Operationen f¨ ur B¨ aume (4)

L¨oschen eines Elements

• Hat das Element nur einen oder keinen Teilbaum, ersetzte das Element durch Teilbaum bzw. NULL.

09 53

05

11 15

20 Zu löschender Knoten: 15

50

09 53

05 11

20

50

Operationen f¨ ur B¨ aume (5)

• Hat das zu l¨oschende Element zwei Teilb¨aume, dann ersetze es durch das gr¨oßte (kleinste) Element seines linken (rechten) Teil- baums. Dieses Element hat keinen rechten (linken) Teilbaum und wird ersetzt wie beschrieben auf der letzten Folie.

09 53

05

11 15

20 Zu löschender Knoten: 20

50

09 53

05 11

15

50

Operationen f¨ ur B¨ aume (6)

Ausgleichen eines Baums

• Notwendig f¨ur eine schnelle Suche: der Baum muss ausgeglichen sein.

• F¨ur die Anzahl der Knoten n in einem Baum der H¨ohe T gilt

⌈log₂(n + 1)⌉ ≤ T ≤ n

• Bei einem vollst¨andig ausgeglichenen Baum liegen alle Bl¨atter auf einer Ebene bzw. die vorletzte Ebene ist voll belegt.

Operationen f¨ ur B¨ aume (7)

Ausgleichen eines Baums

Rekursiver Algorithmus zum Ausgleichen eines Baums:

• Finde das in der Ordnung mittlere Element eines Baums

• Speichere das Element als Wurzel

• Verfahre auf gleiche Art mit den Teilb¨aumen.

Sehr aufwendiges Verfahren, dass nach jedem L¨oschen bzw. Hinzuf¨ugen eines Knotens wiederholt werden m¨usste.

Schw¨achere Definition von Ausgeglichenheit nach Adelson-Vekskii und Landis (1962) ⇒ AVL-B¨aume.

AVL-B¨ aume (1)

In einem AVL-Baum unterscheiden sich die H¨ohen d des linken und des rechten Teilbaums f¨ur jeden Knoten h¨ochstens um 1.

Es ist g¨unstig, die Differenz der H¨ohen der Teilb¨aume bei jedem Kno- ten zu speichern.

09 53

05

11

15 79

20

50

52 08

07 01

0

0

0 0

0

1

-1

-1 1

1

d=1

1

AVL-B¨ aume (2)

Minimale Anzahl n(t) von Knoten:

• Ein Minimaler AVL-Baum der H¨ohe T setzt sich aus einer Wurzel und einem Teilbaum der H¨ohe T − 1 sowie einem Teilbaum der H¨ohe T − 2 zusammen

• minimal Knotenzahl:

n(T) = 1 + n(T − 1) + n(T − 2) = f ib(T + 1) − 1 ≈ 1.61803^T+1

t 1 2 3 4 5 6 7 8

n(t) 1 2 4 7 12 20 33 54 2^t − 1 1 3 7 15 31 63 127 255

• Die H¨ohe eines AVL-Baumes mit n Knoten ist O(log(n))

Rebalancieren von AVL-B¨ aumen (1)

• Ein AVL-Baum hat die H¨ohendifferenz-Werte von d = −1,0,1.

• Einf¨ugen und L¨oschen von Knoten geschieht wie in Suchb¨aumen.

• Durch Einf¨ugen oder L¨oschen k¨onnen Knoten mit d = 2 oder d = −2 entstehen.

• Durch Rotation kann in diesen F¨allen die AVL-Bedingung wieder hergestellt werden.

Beispiel: LL-Rotation

Ein Knoten wird im linken Teilbaum vom linken Teilbaum von K1 ein- gef¨ugt, wobei K1 der Knoten ist, bei dem anschließend d = 2 auftritt.

Rebalancieren von AVL-B¨ aumen (2)

K2

K1

K1 K2

A

B

C

A

B C

d=1

d=2 d=0

d=0

Umh¨angen des rechten Teilbaums von K2 nach K1 und K2 als neuen Wurzelknoten des Teilbaums setzen.

• Setze die “linke” Referenz von K1 auf B.

• Setze die “rechte” Referenz von K2 auf K1.

Rebalancieren von AVL-B¨ aumen (3)

09 53

05

11

15

20

50

08

01 04

0

0

0/1 0

0 1

0/1

d=1/2

1

0/1

53 09

05

11

15

20

50 08

01 04

0 0

1 0

0 1

0

0

1 1

Rebalancieren von AVL-B¨ aumen (4)

• RR-Rotation

Wird ein Knoten im rechten Teilbaum vom rechten Teilbaum von K1 eingef¨ugt, wobei K1 der Knoten ist, bei dem anschließend d = 2 auftritt, so wird eine einfache Rotation analog zur LL- Rotation durchgef¨uhrt.

• LR-(RL) Rotation

Wird ein Knoten im rechten (linken) Teilbaum vom linken (rech- ten) Teilbaum von K1 eingef¨ugt, wobei K1 der Knoten ist, bei dem anschließend d = 2 auftritt, so muss eine Doppelrotation durchgef¨uhrt werden.

Rebalancieren von AVL-B¨ aumen (5)

K2 K1

A

B C

d=1 d=-2

D

K3 K1

K2

A

B C

d=0

d=0

D K3

d=-1

• Umh¨angen des rechten Teilbaums von K2 nach K3

• Umh¨angen des linken Teilbaums von K2 nach K1

• Referenzen von K1, K2, K3 neu setzen

Rebalancieren von AVL-B¨ aumen (6)

• Aufwand des Rebalancierens:

* Werte der H¨ohendifferenz aktualisieren: O(log(n))

* Umh¨angen der Zeiger: O(1)

• Der Gesamtaufwand zum Einf¨ugen eines Knoten betr¨agt wie beim vollst¨andig ausgeglichenen Suchbaum O(log(n)).

• Das L¨oschen eines Knoten geschieht analog zum Einf¨ugen.

• Dementsprechend betr¨agt der Gesamtaufwand zum L¨oschen eines Knoten ebenfalls nur O(log(n)).

Nettes Applet: http://fbim.fh-regensburg.de/~saj39122/bruhi/

Weitere B¨ aume (1)

2-3 und 2-3-4 B¨aume

• Suchb¨aume, deren Knoten aus 2-3-4-Knoten mit 1,2 oder 3 Schl¨usseln sind.

• Der Grad des Baums ist ≤ 4.

• Alle Bl¨atter liegen auf einer Ebene.

• Vorteil: Die B¨aume sind immer ausgeglichen und ein Suchen ist sehr schnell m¨oglich.

• Nachteil: Die B¨aume m¨ussen umgebaut werden, soll ein weiteres Element in einen vollen Baum eingef¨ugt werden.

Weitere B¨ aume (2)

Beispiel: Spalte 4-Knoten mit 3 Schl¨usseln bei weiterem Schl¨ussel in der “Mitte” in zwei 2-Knoten auf und ¨ubergeben einen Schl¨ussel an den Vorg¨anger.

E J N

A B C F G I K L M O P R

F G I K L M O P R

A B D

C E

J

N

D einfügen

Weitere B¨ aume (3)

B-B¨aume:

• Sie stammen von Bayer und McCreight und sind eine Erweiterung der 2-3 bzw. 2-3-4 B¨aume.

B⁺- und B^∗-B¨aume der Ordnung m:

• Motivation f¨ur diese B¨aume waren Datenmengen, die nicht den Speicher passen.

• Sie bestehen aus inneren Knoten, in denen jeweils mindestens [m/2] und h¨ochstens [m] Schl¨ussel - keine Datens¨atze - gespei- chert sind, und aus

• Blattknoten, die jeweils die Datens¨atze, auch Bl¨ocke genannt, ent- halten.

• Die Wurzel darf auch weniger als [m/2] Schl¨ussel enthalten.

Weitere B¨ aume (4)

• Jeder innere Knoten mit n Schl¨usseln ist ein (n + 1)-Knoten und enth¨alt (n + 1) Verweise auf weiter f¨uhrende Teilb¨aume.

• Die Bl¨atter liegen alle auf einer Ebene und enthalten die Da- tens¨atze und ggf. Verweise auf die benachbarten Bl¨atter (lineare Liste).

• B⁺- und B^∗-B¨aume werden manchmal f¨ur die gleiche Struktur verwendet, urspr¨unglich unterscheiden Sie sich aber im Verhalten beim Einf¨ugen und L¨oschen neuer Knoten.

• Es existieren viele weitere Varianten von B-B¨aumen.

Anwendung von B-B¨aumen: XFS oder ReiserFS von Linux, Verwal- tung von Indizes in Datenbanken.