Suchbaum. AVL-Baum Rot-Schwarz B-Baum B*-Baum... -Baum

Transkript

1 Suchbäume Suchbaum Binärer Suchbaum Vielweg-SB AVL-Baum Rot-Schwar B-Baum B*-Baum... -Baum Fast ausgeglichen: Differen der Blatttiefen begrent Ausgeglichen: alle Blätter besiten gleiche Tiefe. Wird für Eternspeicherugiffe verwendet. hs / fub alp Einfügen AVL-Baum Annahme: AVL Knoten k enhält Feld mit Höhe des Baumes, dessen Knoten k ist. (height) Verfahren: Rekursives Traversieren um Einfügepunkt. Rückschreitend: Balance prüfen X l r hs / fub alp

2 AVL-Baum: Einfügen AvlNode insert( Comparable, AvlNode t { if( t == null ) t = new AvlNode(, null, null ); else //recursive call of insert() if(.compareto( t.element ) < 0 ) { t.left = insert(, t.left ); // Balance check after recursive call if( height( t.left ) - height( t.right ) == 2 ) // Check single or double rotation if(.compareto( t.left.element ) < 0 ) t = rotatewithleftchild( t ); else t = doublewithleftchild( t ); } else if(.compareto( t.element ) > 0 )...} // adjust height t.height = ma(height(t.left),height(t.right ) ) + 1; return t; } hs / fub alp Rotieren AvlNode rotatewithleftchild( AvlNode ) {AvlNode =.left;.left =.right;.right = ;.height = ma( height(.left ), height(.right ) ) + 1;.height = ma( height(.left ),.height ) + 1; return ; } hs / fub alp

3 Doppelt rotieren (l r) AvlNode doublewithleftchild( AvlNode ){.left = rotatewithrightchild(.left ); return rotatewithleftchild( ); } 2 ll lr hs / fub alp AVL Bäume: Rotationen ll lr hs / fub alp

4 AVL Bäume: Rotationen 2 2 ll lr hs / fub alp B-Bäume - Motivation Ziel: Persistente Datenspeicherung mit effiientem Zugriff " Lösung:" Daten bei Programmstart in Hauptspeicher laden, Vor Beendigung serialisiert auf Platte schreiben. Schlecht! Problem: Hohe Lese-/Schreibkosten 1 : Besser: Benötigte Daten von der Platte lesen, verändern, urückschreiben. hs / fub alp

5 B-Baum: Suchbaum für Hintergrundspeicher - Mehrweg-Suchbaum mit variablem Grad k, t <= k <=2 t, t: Minimalgrad Wurel: 1 <= k <= 2t - Knoten mit k Unterbäumen enthalten k-1 Werte (Schlüssel, kes) - alle Blätter haben gleiche Tiefe 30 t= , hs / fub alp B + -Baum (manchmal B*-Baum genannt!) Ziel: Großer Verweigungsgrad innerer Knoten Methode: Schlüssel in inneren Knoten, alle Schlüssel-Wert-Paare in Blättern. Wert: Verweis auf Datensat im Hintergrundspeicher B+-Baum mit "Sat"- Schlüsseln Hintergrundspeicher mit Datensäten (wahlfreier Zugriff) hs / fub alp

6 3.3.5 Hash-Verfahren Implementierung von Mengen (und Wörterbücher): Alternative u Suchbäumen to hash: erhacken, Hackfleisch Grundidee: Indeierung der Tabelle mit geeignet transformierten Schlüsselwerten {30,63,15,11,97,19} h() = mod 10 berechnet den den Plat von in der "Hashtabelle" t (in erster Näherung...) t hs / fub alp Hash-Verfahren (1) Hash-Verfahren implementiert ein Wörterbuch (Map, dictionnar), das für einen Schlüssel den ugehörigen Wert liefert. Beispiele: Telefonbuch: Nachname -> Telefonnr; Kasse: Produktcode -> Preis, u.v.m. Gegeben Schlüsselmenge V Funktion h : K -> {0,...,m-1} (Hashfunktion) Wertemenge V (optional, wenn nur Menge von Schlüsseln verwaltet wird) Tabelle tab Entr[] mit tab.length() == m Implementierung: - intern als Feld, etern Folge von Plattenspeicherblöcken -Feldelement vom Tp Entr speichert Schlüssel k und/oder Wert v Tabellenelement ("slots", buckets") kann b Schlüssel k bw. Schlüssel / Wertpaare (k,v) speichern hier: Bucket-Größe b = 1 hs / fub alp

7 Hash-Verfahren (2) Wichtige Operationen: boolean insert(ke k, Object v) { // requires: k!= null // effects: if tab[h(k)].value = v' replace v' b v // else put v into tab[h(k)] if (tab[h(k)] == null) tab[h(k)].value = v else... ; //hash collision Object find : K -> V //.B.:Feldimplementierung Object lookup (Ke k){ if (tab[h(k)].ke) == k) return tab[h(k)].value else??? //collision or not // found?? } hs / fub alp Hash-Kollisionen Hash-Kollision liegt vor, wenn h(k i ) = h(k j ) für k i!= k j Annahme: für jeden Schlüssel k und jedes i, 0<=i<m gilt: Wahrscheinlichkeit (h(k) == i) = 1/m Wie wahrscheinlich sind Kollisionen? n Schlüssel einfügen: W(mindestens eine Kollision) = 1-W(keine Koll.) W(keine K) = 1 * (m-1)/m * (m-2)/m *... * (m-n+1) / m = m! / m n *(m-n)! Bsp.: m=10, n=8: W= , m=20, n=10 W= 1-0,065 hs / fub alp

8 Hash-Kollisionen Gängige Verfahren ur Kollisionsbehandlung: - Offene Adressierung (= geschlossene Hashtabelle): Finde freien Plat in der Tabelle,.B. nächster nicht belegter Plat hier: 3 Versuche, bis freier Plat gefunden. - Verkettung (Chaining) hs / fub alp Laufeit bei Verkettung Mittlere Laufeit "Suche mit Schlüssel k" tab[].length = m n Schlüssel gespeichert Füllungsgrad: α = n/m Annahme: uniformes Hash - Nicht erfolgreiche Suche: für alle i: tab[i] ist Liste der Länge n/m Damit: Suche im Mittel O ( 1 + n/m) und mit der Annahme: n/m = const: O(1) hs / fub alp

9 Laufeit bei Verkettung - Erfolgreiche Suche: 1 + n/2*m - 1/2*m = O(1 + α) Operationen Bewertung: unschlagbar schnelles Einfügen / Suchen... wenn "gute" Hash-Funktion und α nicht u groß Sonst.B. "dnamisches Verändern" der Tabellengröße, aufwendig! Sehr einfache Implementierung hs / fub alp Hash Tabelle mit Verkettung public class HashMapSimple //etends AbstractMap //implements Map { private Entr table[]; //Hash Table private int count; // total number of entries private static class Entr //implements Map.Entr { int hash; Object ke; Object value; Entr net; Entr(int hash, Object ke, Object value) { this.hash = hash; this.ke = ke; this.value = value; }...} hs / fub alp

10 Verkettung: Einfügen public Object insert(object ke, Object value) { // no duplicate kes not in Hash table. Entr tab[] = table; int hash = 0; int inde = 0; hash = ke.hashcode(); inde = (hash & 07FFFFFFF) % tab.length; for (Entr e = tab[inde] ; e!= null ; e = e.net) { if ((e.hash == hash) && ke.equals(e.ke)) { Object old = e.value; e.value = value; return old; } } // Creates the new entr. Entr e = new Entr(hash, ke, value); e.setnet(tab[inde]); //chain in front tab[inde] = e; count++; return null; } hs / fub alp Verkettung: Suchen Suche public Object lookup(object ke) { // search(ke), get(ke)... Entr tab[] = table; int hash = ke.hashcode(); int inde = (hash & 07FFFFFFF) % tab.length; for (Entr e = tab[inde]; e!= null; e = e.net) if ((e.hash == hash) && ke.equals(e.ke)) return e.value; return null; } hs / fub alp