Übersicht. Datenstrukturen und Algorithmen. Übersicht. Motivation. Vorlesung 10: Binäre Suchbäume

Transkript

1 Übersicht Datenstrukturen und lgorithmen Vorlesung : Joost-Pieter Katoen Lehrstuhl für Informatik 2 Software Modeling and Verification Group 1 Suche Einfügen Einige Operationen (die das Löschen vereinfachen) Löschen 2 8. Mai Joost-Pieter Katoen Datenstrukturen und lgorithmen 1/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 2/3 Übersicht Motivation 1 Suche Einfügen Einige Operationen (die das Löschen vereinfachen) Löschen 2 Suchbäume unterstützen Operationen auf dynamischen Mengen, wie: Suchen, Einfügen, Löschen, bfragen (z.. Nachfolger oder minimales Element) Die asisoperationen auf binären Suchbäumen benötigen eine Laufzeit, die proportional zur Höhe des aums ist. Für vollständige binäre äume mit n Elementen liefert dies eine Laufzeit in Θ(log(n)) für eine asisoperation. Für einen aum, der einer linearen Kette entspricht, ist dies jedoch in Θ(n). Wir werden später binäre Suchbäume kennen lernen, deren Operationen immer Laufzeiten in Θ(log(n)) haben (s. nächste Vorlesung). Joost-Pieter Katoen Datenstrukturen und lgorithmen 3/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 4/3

2 (I) (II) inärer Suchbaum Ein binärer Suchbaum (ST) ist ein inärbaum, der Elemente mit Schlüsseln enthält, wobei der Schlüssel jedes Knotens mindestens so groß wie jeder Schlüssel im linken Teilbaum und höchstens so groß wie jeder Schlüssel im rechten Teilbaum ist. Knoten in einem binären Suchbaum bestehen aus vier Feldern: Einem Schlüssel dem Wert des Knotens, einem (möglicherweise leeren) linken und rechten Teilbaum (bzw. Zeiger darauf) sowie einem Zeiger auf den Vater-/Mutterknoten (bei der Wurzel leer) Schlüssel 12 null Vater/Mutter von und 2 Zwei binäre Suchbäume, die jeweils die Schlüssel 2, 3,,, 7, 9 enthalten Linkes Kind von left parent right 22 Rechtes Kind von Joost-Pieter Katoen Datenstrukturen und lgorithmen /3 Joost-Pieter Katoen Datenstrukturen und lgorithmen /3 (III) Sortieren in linearer Zeit? eispiel (inärer Suchbaum in /++) 1 typedef struct _* Node; 2 struct _ { 3 int key; 4 Node left, right; Node parent; //... evtl. eigene Datenfelder 7 }; 9 struct _tree { Node root; 11 }; 12 typedef struct _tree* Tree; Sortieren Eine Inorder Traversierung eines binären Suchbaumes gibt alle Schlüssel im Suchbaum in sortierter Reihenfolge aus. Die Korrektheit dieses Sortierverfahrens folgt per Induktion direkt aus der ST-Eigenschaft. eispiel eispiel Inorder Traversierung ST am Overheadprojektor. Zeitkomplexität Da die Zeitkomplexität einer Inorder Traversierung eines aumes mit n Knoten Θ(n) ist, liefert uns dies einen Sortieralgorithmus in Θ(n). Dies setzt jedoch voraus, dass alle Daten als ein ST gespeichert sind. Joost-Pieter Katoen Datenstrukturen und lgorithmen 7/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 8/3

3 Suche nach Schlüssel k im ST k = Suche nach Schlüssel k im ST k = 18 (erfolglos) 1 Node bstsearch(node root, int k) { 2 while (root) { 3 if (k < root.key) { 4 root = root.left; } else if (k > root.key) { root = root.right; 7 } else { // k == root.key return root; } } 11 return null; // nicht gefunden 12 } 1 1 Node bstsearch(node root, int k) { 2 while (root) { 3 if (k < root.key) { 4 root = root.left; } else if (k > root.key) { root = root.right; 7 } else { // k == root.key return root; } } 11 return null; // nicht gefunden 12 } 1 Die Worst-ase Komplexität ist linear in der Höhe h des aumes: Θ(h). Für einen kettenartigen aum mit n Knoten ergibt das Θ(n). Ist der ST so balanciert wie möglich, erhält man Θ(log(n)). Funktioniert dieses Suchverfahren auch bei Heaps? Nein. Die Worst-ase Komplexität ist linear in der Höhe h des aumes: Θ(h). Für einen kettenartigen aum mit n Knoten ergibt das Θ(n). Ist der ST so balanciert wie möglich, erhält man Θ(log(n)). Funktioniert dieses Suchverfahren auch bei Heaps? Nein. Joost-Pieter Katoen Datenstrukturen und lgorithmen 9/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 9/3 Einfügen eines Knotens mit Schlüssel k Strategie Einfügen von 18 in den ST t eispiel Einfügen Man kann einen neuen Knoten mit Schlüssel k in den ST t einfügen, ohne die ST-Eigenschaft zu zerstören: Suche einen geeigneten, freien Platz: Wie bei der regulären Suche, außer dass, selbst bei gefundenem Schlüssel, weiter abgestiegen wird, bis ein Knoten ohne entsprechendes Kind erreicht ist. Hänge den neuen Knoten an: Verbinde den neuen Knoten mit dem gefundenen Vaterknoten. eispiel 14 bstins(t, Node(18)) Komplexität: Θ(h), wegen der Suche. Joost-Pieter Katoen Datenstrukturen und lgorithmen /3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 11/3

4 Einfügen in einen ST lgorithmus 1 void bstins(tree t, Node ) { // Füge in den aum t ein 2 // Suche freien Platz 3 Node root = t.root, parent = null; 4 while (root) { parent = root; if (.key < root.key) { 7 root = root.left; 8 } else { 9 root = root.right; } 11 } // Einfügen 12.parent = parent; 13 if (!parent) { // t war leer => neue Wurzel 14 t.root = ; } else if (.key < parent.key) { // richtige Seite... 1 parent.left = ; 17 } else { 18 parent.right = ; 19 } } bfragen im ST: Minimum Wir suchen den Knoten mit kleinstem Schlüssel im durch root gegebenen (Teil-)aum. 1 Node bstmin(node root) { // root!= null 2 while (root.left) { 3 root = root.left; 4 } return root; } Komplexität: Θ(h) bei aumhöhe h. nalog kann das Maximum gefunden werden. Joost-Pieter Katoen Datenstrukturen und lgorithmen 12/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 13/3 bfragen im ST: Nachfolger (I) Wir suchen den Nachfolger-Knoten von, also den bei Dessen Schlüssel ist mindestens so groß wie.key. bfragen im ST: Nachfolger (I) Wir suchen den Nachfolger-Knoten von, also den bei Dessen Schlüssel ist mindestens so groß wie.key Joost-Pieter Katoen Datenstrukturen und lgorithmen 14/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 14/3

5 bfragen im ST: Nachfolger (I) Wir suchen den Nachfolger-Knoten von, also den bei Dessen Schlüssel ist mindestens so groß wie.key. bfragen im ST: Nachfolger (I) Wir suchen den Nachfolger-Knoten von, also den bei Dessen Schlüssel ist mindestens so groß wie.key. Der rechte Teilbaum existiert: Der Nachfolger ist der kleinste Knoten im rechten Teilbaum Der rechte Teilbaum existiert: Der Nachfolger ist der kleinste Knoten im rechten Teilbaum. ndernfalls: Der Nachfolger ist der jüngste Vorfahre, dessen linker Teilbaum enthält Joost-Pieter Katoen Datenstrukturen und lgorithmen 14/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 14/3 bfragen im ST: Nachfolger (I) Wir suchen den Nachfolger-Knoten von, also den bei Dessen Schlüssel ist mindestens so groß wie.key. bfragen im ST: Nachfolger (I) Wir suchen den Nachfolger-Knoten von, also den bei Dessen Schlüssel ist mindestens so groß wie.key. Der rechte Teilbaum existiert: Der Nachfolger ist der kleinste Knoten im rechten Teilbaum. ndernfalls: Der Nachfolger ist der jüngste Vorfahre, dessen linker Teilbaum enthält Der rechte Teilbaum existiert: Der Nachfolger ist der kleinste Knoten im rechten Teilbaum. ndernfalls: Der Nachfolger ist der jüngste Vorfahre, dessen linker Teilbaum enthält Komplexität: Θ(h) bei aumhöhe h. Komplexität: Θ(h) bei aumhöhe h. nalog kann der Vorgänger gefunden werden. Joost-Pieter Katoen Datenstrukturen und lgorithmen 14/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 14/3

6 bfragen im ST: Nachfolger (II) Der rechte Teilbaum existiert: Der Nachfolger ist der kleinste Knoten im rechten Teilbaum. ndernfalls: Der Nachfolger ist der jüngste Vorfahre, dessen linker Teilbaum enthält. 1 Node bstsucc(node ) { //!= null 2 if (.right) { 3 return bstmin(.right); 4 } // bbruch, wenn nicht mehr rechtes Kind ist (also linkes!) // oder.parent leer ist (also kein Nachfolger existiert). 7 while (.parent &&.parent.right == ) { 8 =.parent; 9 } return.parent; 11 } Ersetzen von Teilbäumen im ST 1 // Ersetzt im aum t den Teilbaum old durch 2 // den Teilbaum (ohne Sortierung!) 3 void bstreplace(tree t, Node old, Node ) { 4 if () { // erlaube == null!.parent = old.parent; } 7 if (!old.parent) { // war die Wurzel 8 t.root = ; 9 } else if (old == old.parent.left) { // war linkes Kind 11 old.parent.left = ; 12 } else { // rechtes Kind 13 old.parent.right = ; 14 } } Das Ersetzen eines Teilbaums hat die Zeitkomplexität Θ(1). Joost-Pieter Katoen Datenstrukturen und lgorithmen /3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 1/3 ustauschen von Knoten im ST 1 // Tauscht den Knoten old gegen aus; 2 // die Kinder von old sind weiter im ST! 3 void bstswap(tree t, Node old, Node ) { 4 // übernimm linken Teilbaum.left = old.left; // auch möglich: swap() if (.left) { 7.left.parent = ; 8 } 9 // rechten Teilbaum.right = old.right; 11 if (.right) { 12.right.parent = ; 13 } 14 // füge den Knoten ein bstreplace(t, old, ); 1 } Löschen im ST: Die beiden einfachen Fälle Das ustauschen eines Knotens hat die Zeitkomplexität Θ(1). Joost-Pieter Katoen Datenstrukturen und lgorithmen 17/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 18/3

7 Löschen im ST: Der aufwändigere Fall Löschen im ST Strategie Löschen Um Knoten aus dem ST zu löschen, verfahren wir folgendermaßen: hat keine Kinder: Ersetze im Vaterknoten von den Zeiger auf durch null. hat ein Kind: Wir schneiden aus, indem wir den Vater und das Kind direkt miteinander verbinden (den Teilbaum ersetzen). hat zwei Kinder: Wir finden den Nachfolger von, entfernen ihn aus seiner ursprünglichen Position und tauschen gegen den Nachfolger. 14 Es tritt nur der erste Fall (bstmin(.right)) aus bstsucc auf. Der gesuchte Nachfolger hat kein linkes Kind. Joost-Pieter Katoen Datenstrukturen und lgorithmen 19/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen /3 Löschen im ST lgorithmus Komplexität der Operationen auf STs 1 // Entfernt aus dem aum. 2 // Danach kann ggf. auch aus dem Speicher entfernt werden. 3 void bstdel(tree t, Node ) { 4 if (.left &&.right) { // zwei Kinder Node tmp = bstmin(.right); bstdel(t, tmp); // höchstens ein Kind, rechts 7 bstswap(t,, tmp); 8 } else if (.left) { // ein Kind, links 9 bstreplace(t,,.left); } else { // ein Kind, oder kein Kind (.right == null) 11 bstreplace(t,,.right); 12 } 13 } Operation Zeit bstsearch Θ(h) bstsucc Θ(h) bstmin Θ(h) bstins Θ(h) bstdel Θ(h) lle Operationen sind linear in der Höhe h des STs. Die Höhe ist log 2 (n), wenn der aum nicht zu unbalanciert ist. Man kann einen binären aum mittels wieder balancieren. Joost-Pieter Katoen Datenstrukturen und lgorithmen 21/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 22/3

8 Zufällig erzeugte binäre Suchbäume Übersicht Zufällig erzeugter ST Ein zufällig erzeugter ST mit n Elementen ist ein ST, der durch das Einfügen von n (unterschiedlichen) Schlüsseln in zufälliger Reihenfolge in einen anfangs leeren aum entsteht. nnahme: jede der n! möglichen Einfügungsordnungen hat die gleiche Wahrscheinlichkeit. Theorem (ohne eweis) Die erwartete Höhe eines zufällig erzeugten STs mit n Elementen ist O(log(n)). 1 Suche Einfügen Einige Operationen (die das Löschen vereinfachen) Löschen 2 Fazit: Im Schnitt verhält sich eine binäre Suchbaum wie ein (fast) balancierter Suchbaum. Joost-Pieter Katoen Datenstrukturen und lgorithmen 23/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 24/3 leftrotate Konzept und eispiel 1 leftrotate(1) 2 1 rightrotate(2) eispiel leftrotate() : Eigenschaften und Komplexität 1 leftrotate(1) 2 1 rightrotate(2) 2 Lemma Ein rotierter ST ist ein ST Die Inorder-Traversierung beider äume bleibt unverändert. Zeitkomplexität Die Zeitkomplexität von Links- oder Rechtsrotieren ist in Θ(1). Joost-Pieter Katoen Datenstrukturen und lgorithmen 2/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 2/3

9 leftrotate lgorithmus 1 void leftrotate(tree t, Node 1) { // analog: rightrotate() 2 Node 2 = 1.right; 3 // aum verschieben 4 1.right = 2.left; 1 if (1.right) { 2 1.right.parent = 1; 7 } 8 // 2 wieder einhängen 9 2.parent = 1.parent; if (!1.parent) { // 1 war die Wurzel 11 t.root = 2; 12 } else if (1 == 1.parent.left) { // war linkes Kind 13 2.parent.left = 2; 2 } else { // war rechtes Kind 2.parent.right = 2; } // 1 einhängen 18 2.left = 1; 19 1.parent = 2; } VL-aum n welchen Knoten müssen die durchgeführt werden? VL-aum Ein VL-aum ist ein balancierter ST, bei dem für jeden Knoten die Höhe der beiden Teilbäume höchstens um 1 differiert. ei VL-äumen wird die Höhe der Teilbäume der Knoten balanciert. Dazu wird (in einem zusätzlichem Datenfeld) an jedem Knoten über die Höhe dieses Unterbaums uch geführt. Nach jeder (kritischen) Operation wird die alance wiederhergestellt. Dies ist in Θ(h) möglich! Dadurch bleibt stets h Θ(log(n)) und Θ(log(n)) kann für die Operationen auf dem ST garantiert werden. Eine andere Möglichkeit, um äume zu balancieren, sind Rot-Schwarz-äume (nächste Vorlesung). Joost-Pieter Katoen Datenstrukturen und lgorithmen 27/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 28/3 VL-äume: alancieren nach Einfügen etrachten wir einen VL-aum. Jeder VL-aum ist (höhen-)balanciert, d. h., für alle Knoten x: rechte Teilbaumhöhe linke Teilbaumhöhe 1. }{{} balance(x) VL-äume: alancieren nach Einfügen Sei der tiefste unbalancierte Knoten auf dem Pfad von der Wurzel zum neu eingefügten Knoten (unbalanciert: linke Teilbaumhöhe rechte Teilbaumhöhe = ±2). RR: Linksrotation auf : Wir fügen einen neuen Knoten in den aum ein. Dadurch kann der aum unbalanciert werden. alancierung durch Rotation. Rechter Teilbaum ist größer: Zwei Fälle RR und RL Rechtsrotation auf : Linksrotation auf : Einfachrotation, wenn die tieferen lätter außen liegen. Doppelrotation, wenn die tieferen lätter innen liegen. RL: Zwei analoge Fälle: Joost-Pieter Katoen Datenstrukturen und lgorithmen 29/3 Rechtsrotation auf : Linksrotation auf : Joost-Pieter Katoen Datenstrukturen und lgorithmen 30/3

10 VL-äume: alancieren nach Einfügen Sei der tiefste unbalancierte Knoten auf dem Pfad von der Wurzel zum neu eingefügten Knoten (unbalanciert: linke Teilbaumhöhe rechte Teilbaumhöhe = ±2). VL-äume: alancieren nach Einfügen Linker Teilbaum ist größer: Zwei Fälle LL und LR LL: Rechtsrotation auf : Linksrotation auf : Rechtsrotation auf : 1 void VLIns(Tree t, Node ) { 2 bstins(t,); 3 //Node deepestunbalancednode(tree t, Node ) 4 //gibt null zurück wenn t balanciert ist //und den tiefsten unbalancierten Knoten in t sonst //(der Parameter wird zur effizienten Implementierung 7 //verwendet) 8 Node = deepestunbalancednode(t,); 9 if (!= null) balance(t, ); } LR: Zwei analoge Fälle: Linksrotation auf : Rechtsrotation auf : Joost-Pieter Katoen Datenstrukturen und lgorithmen 31/3 Joost-Pieter Katoen Datenstrukturen und lgorithmen 32/3 VL-äume: alancieren nach Einfügen 1 void balance(tree t, Node ){ 2 // ist tiefster unbalancierter Knoten in t 3 if (height(.left) > height(.right)) { 4 if (height(.left.left) >= height(.left.right)) { //LL rightrotate(t,); } else { //LR 7 leftrotate(.left); rightrotate(); 8 } 9 } else { if (height(.right.right) >= height(.right.left)) { //RR 11 leftrotate(t,); 12 } else { //RL 13 rightrotate(.right); leftrotate(); 14 } } 1 } Joost-Pieter Katoen Datenstrukturen und lgorithmen 33/3 VL-äume: alancieren nach Löschen aumhöhe von nach der Rotation ist wieder die gleiche wir vor dem Einfügen des neuen Knotens. Das heißt, nach dem alancieren von ist der gesamte aum wieder balanciert. Die zweite Operation, die Unbalanciertheit verursachen kann, ist das Löschen eines Knotens. Die alancierung des tiefsten unbalancierten Knotens kann auf die gleiche Weise erreicht werden wie beim Einfügen. ber: der Teilbaum hat nicht die gleiche Höhe wie vor dem Löschen (sie ist um 1 kleiner)! Im schlimmsten Fall müssen alle unbalancierten Knoten einzeln balanciert werden. Da aber die alancierung eines Knotens nur einen konstanten ufwand erfordert und es nur O(log(n)) unbalancierte Knoten geben kann, ist der ufwand immer noch logarithmisch. Joost-Pieter Katoen Datenstrukturen und lgorithmen 34/3

11 VL-äume: alancieren nach Löschen 1 void VLDel(Tree t, Node ) { 2 bstdel(t,); 3 //Node deepestunbalancednode(tree t, Node ) 4 //gibt null zurück wenn t balanciert ist //und den tiefsten unbalancierten Knoten in t sonst //(der Parameter wird zur effizienten Implementierung 7 //verwendet) 8 Node = deepestunbalancednode(t,); 9 while (!= null) { //bool balanced(tree t, Node ) 11 //gibt true zurück wenn balanciert ist in t 12 //und false sonst 13 if (!balanced(t, )) { 14 balance(t, ); =.parent.parent; 1 } else { 17 =.parent; 18 } 19 } } Joost-Pieter Katoen Datenstrukturen und lgorithmen 3/3