Der linke Teilbaum von v enthält nur Schlüssel < key(v) und der rechte Teilbaum enthält nur Schlüssel > key(v)

Transkript

1 Ein Baum T mit Knotengraden 2, dessen Knoten Schlüssel aus einer total geordneten Menge speichern, ist ein binärer Suchbaum (BST), wenn für jeden inneren Knoten v von T die Suchbaumeigenschaft gilt: Der linke Teilbaum von v enthält nur Schlüssel < key(v) und der rechte Teilbaum enthält nur Schlüssel > key(v) Äquivalent: Die Schlüssel im Baum T sind bzgl. einer Inorder Traversierung aufsteigend sortiert 18

2 Die Ordnungsbedingung kann von < zu bzw. von > zu abgeschwächt werden, um mehrfaches Auftreten des gleichen Wertes zu ermöglichen Kleine Modifikationen der vorgestellten Algorithmen nötig! Binäre Suchbäume gehören zu den wichtigsten Datenstrukturen in der gesamten Informatik. Mit binären Suchbäumen kann man mächtige Datenstrukturen (Dictionaries, Prioritätswarteschlangen, etc.) sehr effizient (oft in optimaler Zeit) implementieren. Die Grundoperationen Suchen, Einfügen, und Entfernen benötigen Zeit proportional zur Höhe des Baumes. Man kann binäre Suchbäume mit n Knoten balancieren, d.h. man kann sie so konstruieren, dass ihre Höhe (log n) ist. Die besondere Schwierigkeit besteht nicht darin, einen solchen Suchbaum zu erzeugen, sondern die Balanciertheit bei einer Folge von Einfüge- und Löschoperationen zu erhalten 19

3 Implementierung binärer Suchbäume: Jeder Knoten hat die Attribute element, left und right für den Zugriff auf seinen Schlüssel und seine beiden Kinder. In manchen Anwendungen ist es sinnvoll, auch ein Attribut parent (Referenz auf den Elternknoten) zu speichern. Baumknoten vom Typ BSTNode<E extends Comparable<E>> mit Datenfeld element (vom Typ E), Zeiger left auf linken Teilbaum und Zeiger right auf rechten Teilbaum linker Teilbaum leer left == null rechter Teilbaum leer right == null Zeiger root auf Wurzel des Baumes 20

4 class BSTNode<E extends Comparable<E>> { private E element = null; private BSTNode<E> left = null; private BSTNode<E> right = null; BSTNode() { } public BSTNode(E element, BSTNode<E> left, BSTNode<E> right) { this.element = element; this.left = left; this.right = right; } // Zugriffsmethoden etc. } // class BSTNode Im folgenden Pseudocode mit BSTNode<E> root; < und > statt compareto!!! 21

5 Suchen in binären Suchbäumen: Der gesuchte Wert x wird mit dem Schlüssel y des Wurzelknotens v verglichen v = null: Mißerfolg x = y: Erfolg, Schlüssel gefunden x < y: weitersuchen in v.left x > y: weitersuchen in v.right Das Suchen kann man iterativ oder rekursiv implementieren 22

6 Rekursive Implementierung: BSTNode<E> find(e x, BSTNode<E> t) { if (t == null) // x nicht gefunden! return null; else if (x < t.element) // suche links return find(x, t.left); else if (x > t.element) // suche rechts return find(x, t.right); else // x gefunden return t; } Pseudocode mit < und > statt compareto!!! 23

7 Iterative Implementierung: BSTNode<E> find(e x) { BSTNode<E> t = root; while ((t!= null) && (t.element!= x)) if (x < t.element) // suche links t = t.left; else if (x > t.element) // suche rechts t = t.right; return t; } Pseudocode mit < und > statt compareto!!! 24

8 Minimum und Maximum: Den kleinsten (bzw. größten) Schlüssel im Suchbaum findet man, indem man solange in den linken (bzw. rechten) Teilbaum absteigt, bis man nicht mehr weiterkommt E findmax(bstnode<e> t) { if (t == null) return null; if (t.right == null) return t.element; return findmax(t.right); } 25

9 Einfügen in binären Suchbäumen: Zum Einfügen eines Schlüssels x wird von der Wurzel aus die Einfügestelle gesucht. Wenn der Schlüssel gefunden wird, ist nichts zu tun (vorausgesetzt, man will keine Duplikate speichern). Andernfalls landet man bei einem leeren Teilbaum, dieser wird durch einen neuen Knoten mit dem Schlüssel x ersetzt. 26

10 Rekursive Implementierung: insert gibt Zeiger auf die Wurzel des Teilbaums zurück, in den x eingefügt wird, d.h. bei nicht-leerem Teilbaum den Wert von t und bei leerem Teilbaum Referenz auf neue Wurzel. Zurückgegebener Zeiger stellt sicher, dass bei nichtleerem Baum der neu eingefügte Knoten mit seinem Elternknoten verlinkt wird. BSTNode<E> insert(e x, BSTNode<E> t) { if (t == null) // x nicht vorhanden t = new BSTNode(x, null, null); else if (x < t.element) // gehe links t.left = insert(x, t.left); else if (x > t.element) // gehe rechts t.right = insert(x, t.right); return t; } Aufruf: root = insert(x, root) Pseudocode mit < und > statt compareto!!! 27

11 Iterative Implementierung: void insert(e x) { BSTNode<E> p = root; BSTNode<E> o = null; while (p!= null) { // steige ab o = p; if (x < p.element) // gehe links p = p.left; } else if (x > p.element) // gehe rechts p = p.right; else // x gefunden! return; // Nichts passiert! } p = new BSTNode(x, null, null); if (root == null) // Baum war leer Aufruf: root = p; // p ist neue Wurzel! else if (x < o.element) o.left = p; // Verbindet p mit Baum else // x > o.element o.right = p; // Verbindet p mit Baum insert(x); Pseudocode mit < und > statt compareto!!! 28

12 Entfernen in binären Suchbäumen: Beim Löschen eines Schlüssels x sind drei Fälle zu unterscheiden (Suchbaumeigenschaft muss erhalten bleiben): x ist in einem Knoten k enthalten, der keine Kinder hat: k wird gelöscht x ist in einem Knoten k enthalten, der ein Kind hat: k wird durch das Kind ersetzt 29

13 x ist in einem Knoten k enthalten, der zwei Kinder hat: Dann bleibt Knoten k erhalten. Das Element x in k wird ersetzt durch das größte Element im linken Teilbaum oder das kleinste Element im rechten Teilbaum von k. Jedes dieser beiden Elemente ist in einem Knoten gespeichert, der höchstens ein Kind besitzt und daher wie in Fall 1 oder 2 entfernt werden kann. 30

14 Rekursive Implementierung: Methode delete versucht, ein Element x in einem Teilbaum zu löschen, auf dessen Wurzel t verweist. Ist x nicht im Teilbaum enthalten, so erfolgt keine Veränderung des Teilbaums. delete gibt einen Zeiger auf die Wurzel des Teilbaums zurück, in dem x gelöscht wurde. Diese Form des Entfernens ist nicht symmetrisch bezüglich links und rechts, weil immer aus dem linken Teilbaum ein Schlüssel hochgeholt wird. Bei sehr vielen Löschoperationen kann das dazu führen, dass der Suchbaum Schlagseite nach rechts bekommt. 31

15 BSTNode<E> delete(e x, BSTNode<E> t) { if (t == null) // x nicht gefunden! return t; else if (x < t.element) // gehe links t.left = delete(x, t.left); else if (x > t.element) // gehe rechts t.right = delete(x, t.right); else // x gefunden! if ((t.left!= null) && (t.right!= null)) { t.element = findmax(t.left); t.left = delete(t.element, t.left) } else if (t.left!= null) } t = t.left; else t = t.right; return t; Aufruf: Pseudocode mit < und > statt compareto!!! root = delete(x, root); 32

16 Iterative Implementierung mit Platzhalter: Elegante, iterative Implementierung eines binären Suchbaums benutzt Platzhalter (Sentinel), zugreifbar durch externen Zeiger s Sentinel speichert kein Element permanent. Linker Zeiger des Sentinel verweist auf Wurzelknoten des Suchbaums, rechter Zeiger verweist auf Sentinel selbst In einem Baumknoten ohne linkes oder rechtes Kind verweist entsprechender Zeiger auf Sentinel Leerer Baum wird durch Sentinel allein dargestellt: s sentinel 33

17 Beispiel: Sentinel für nichtleeren Suchbaum s sentinel Bei der Suche nach einem Element x wird x im Sentinel gespeichert Sicherstellung der Terminierung der Suche spätestens im Sentinel 34

18 Implementierung von insert: void insert(e x) { s.element = x; BSTNode<E> p = s.left; BSTNode<E> o = s; while (p.element!= x) { o = p; if (x < p.element) p = p.left; else p = p.right; } Aufruf: } if (p == s) { p = new BSTNode(x, s, s); if (x > o.element) o.right = p; else o.left = p; } s.element = null; insert(x); Pseudocode mit < und > statt compareto!!! 35

19 Natürliche Suchbäume: Wenn man eine Folge (x 1,..., x n ) von Schlüsseln in einen anfänglich leeren binären Suchbaum einfügt, erhält man den natürlichen binären Suchbaum zu dieser Folge Beispiel: Schlüsselfolge A S E R C H I N G X M P L Es gibt im allgemeinen mehrere Reihenfolgen der Schlüssel, die zum selben natürlichen Suchbaum führen. Bsp. hätte man X zu irgendeinem Zeitpunkt nach A S einfügen können es wäre immer derselbe Baum entstanden. 36

20 Komplexitätsanalyse: Bei jedem Zugriff (Suchen/Einfügen/Entfernen) wird ein von der Wurzel ausgehender Suchpfad durchlaufen. Im besten Fall ist der Baum vollständig und alle Suchpfade haben eine Länge O(log n). Im schlechtesten Fall ist der Baum zu einer linearen Liste ausgeartet, z.b. wenn die Schlüssel in sortierter Reihenfolge eingefügt wurden. Dann hat der Baum eine Höhe von O(n). Dieses Problem kann man vermeiden, indem man während des Einfügens den Baum jeweils balanciert ( ausgeglichene Bäume). 37

21 Zwei Beispiele für den ungünstigsten Fall. Der Suchbaum entartet zu einer einfachen verketteten Liste, was zu quadratischer Konstruktionszeit und linearer Suchzeit führt. 38

22 Mittlerer Fall: Die mittlere Laufzeit eines Zugriffs ist proportional zur durchschnittlichen Pfadlänge 1/n w(t). w(t): Summe der Tiefenwerte aller Knoten im Suchbaums t. Bei ausgearteten Bäumen ist auch die mittlere Zugriffszeit O(n) Bei zufällig erzeugten Schlüsseln: Dann ist das Verhalten i.d.r gut, der natürliche Suchbaum ist von selber einigermaßen ausgeglichen Zufällig erzeugt kann verschiedene Bedeutungen haben. Annahme: Jede Permutation der Schlüssel ist gleich wahrscheinlich Der Baum ist der natürliche Suchbaum zur Eingabe (kein Entfernen) Dann steht jeder Schlüssel mit gleicher Wahrscheinlichkeit in der Wurzel 39

23 Eigenschaft: Der Zugriff auf einen zufällig erzeugten binären Suchbaum dauert im Mittel nur knapp 40% länger als der Zugriff auf einen optimalen binären Suchbaum. Beweis Sei w n die Summe der Tiefenwerte aller Knoten eines solchen zufällig erzeugten Suchbaums mit n Schlüsseln. Dann gilt: Der (zuerst eingefügte) Schlüssel an der Wurzel ist gleich wahrscheinlich wie der k-größte Schlüssel und bewirkt somit zufällige Teilbäume der Größe k-1 und n-k. 40

24 Durch Differenzbildung von wird man die beiden langen Summen los Mit der Bezeichnung p n = w n /(n+1) ergibt sich Daraus erhält man schließlich die Lösung Das ist zugleich die gesuchte Größenordnung von 1/n w n 41

25 Beispiel: Dieser binäre Suchbaum wurde durch Einfügen von etwa 200 zufälligen Schlüsseln in einen anfangs leeren Baum erstellt. Keine Suche benötigt mehr als 12 Vergleiche. Die durchschnittlichen Kosten für einen Suchtreffer betragen ungefähr 7. Ein binärer Suchbaum, der aus zufällig geordneten Schlüsseln aufgebaut wird, ist höchstwahrscheinlich gut ausgeglichen 42