Binäre Suchbäume. Organisatorisches. VL-10: Binäre Suchbäume. (Datenstrukturen und Algorithmen, SS 2017) Gerhard Woeginger.

Transkript

1 Organisatorisches VL-10: inäre Suchbäume (Datenstrukturen und lgorithmen, SS 17) Gerhard Woeginger Vorlesung: Gerhard Woeginger (Zimmer 4024 im E1) Sprechstunde: Mittwoch 11: 12:00 Übungen: Tim Hartmann, David Korzeniewski, jörn Tauer Webseite: SS 17, RWTH Nächste Vorlesung: Dienstag, Mai 23, 1: 17:4 Uhr, ula 1 DSL/SS 17 VL-10: inäre Suchbäume 1/43 DSL/SS 17 VL-10: inäre Suchbäume 2/43 Motivation inäre Suchbäume Suchbäume unterstützen Operationen auf dynamischen Mengen, wie: Suchen Einfügen Löschen bfragen (Nachfolger, oder Minimum, oder Maximum, etc) Suchen Einfügen Löschen Rotationen VL-äume Die asisoperationen auf binären Suchbäumen benötigen Laufzeit proportional zur Höhe des aums: Für vollständige binäre äume mit n Elementen liefert dies eine Laufzeit von Θ(log n) pro asisoperation. Für einen aum, der einer linearen Kette mit n Elementen entspricht, ist dies aber Θ(n). In der nächsten Vorlesung (VL-11) werden wir binäre Suchbäume kennenlernen, deren Operationen immer Laufzeiten in O(log n) haben DSL/SS 17 VL-10: inäre Suchbäume 3/43 DSL/SS 17 VL-10: inäre Suchbäume 4/43

2 inäre Suchbäume (1) Definition: 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 gross ist wie jeder Schlüssel im linken Teilbaum und höchstens so gross ist wie jeder Schlüssel im rechten Teilbaum inäre Suchbäume (2) Ein Knoten in einem binären Suchbaum besteht aus vier Feldern: Einem Schlüssel = dem Wert des Knotens einem (möglicherweise leeren) linken und einem (möglicherweise leeren) rechten Teilbaum, bzw. Zeiger darauf 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 sechs Schlüssel 2, 3,,, 7, 9 enthalten Linkes Kind von left parent right 22 Rechtes Kind von DSL/SS 17 VL-10: inäre Suchbäume /43 DSL/SS 17 VL-10: inäre Suchbäume /43 inäre Suchbäume (3) inäre Suchbäume (4) eispiel (inärer Suchbaum in /++) 1 typedef struct _node * Node ; 2 struct _node { 3 int key ; 4 Node left, right ; Node parent ; //... evtl. eigene Datenfelder 7 }; 8 9 struct _tree { 10 Node root ; 11 }; typedef struct _tree * Tree ; Sortieren Eine Inorder Traversierung eines binären Suchbaumes gibt alle Schlüssel im Suchbaum in sortierter Reihenfolge aus. Zeitkomplexität Da eine Inorder Traversierung eines aumes mit n Knoten nur Θ(n) Zeit benötigt, erhalten wir einen Sortieralgorithmus mit Laufzeit Θ(n). Dies setzt jedoch voraus, dass alle Daten bereits als ein ST abgespeichert sind. DSL/SS 17 VL-10: inäre Suchbäume 7/43 DSL/SS 17 VL-10: inäre Suchbäume 8/43

3 Suche nach Schlüssel k im ST Suchen 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 8 return root ; } 9 } 10 return null ; // nicht gefunden 11 } 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 balanziert wie möglich, erhält man Θ(log(n)). Frage: Funktioniert dieses Suchverfahren auch bei Heaps? DSL/SS 17 VL-10: inäre Suchbäume 9/43 DSL/SS 17 VL-10: inäre Suchbäume 10/43 eispiel: Suche nach Schlüssel k im ST (1) eispiel: Suche nach Schlüssel k im ST (2) Erfolgreiche Suche nach Schlüssel k = 10 Erfolglose Suche nach Schlüssel k = 18 DSL/SS 17 VL-10: inäre Suchbäume 11/43 DSL/SS 17 VL-10: inäre Suchbäume 12/43

4 Einfügen eines Knotens: Strategie Einfügen 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, ausser dass, selbst bei gefundenem Schlüssel, weiter abgestiegen wird, bis dass ein Knoten ohne entsprechendes Kind erreicht ist. Hänge den neuen Knoten an: Verbinde den neuen Knoten mit dem gefundenen Vaterknoten. Komplexität: Θ(h), wegen der Suche. DSL/SS 17 VL-10: inäre Suchbäume 13/43 DSL/SS 17 VL-10: inäre Suchbäume 14/43 eispiel: Einfügen von Schlüssel k = 18 in ST Einfügen eines Knotens: lgorithmus eispiel bstins(t, Node(18)) void bstins ( Tree t, Node node ) { // Fuege node in t ein 2 // Suche freien Platz 3 Node root = t. root, parent = null ; 4 while ( root ) { parent = root ; if ( node. key < root. key ) { 7 root = root. left ; 8 } else { 9 root = root. right ; 10 } 11 } // Einfuegen 12 node. parent = parent ; 13 if (! parent ) { // t war leer => neue Wurzel 14 t. root = node ; } else if ( node. key < parent. key ) { // richtige Seite 1 parent. left = node ; 17 } else { 18 parent. right = node ; 19 } } DSL/SS 17 VL-10: inäre Suchbäume /43 DSL/SS 17 VL-10: inäre Suchbäume 1/43

5 bfragen im ST: Minimum bfragen Problem Wir suchen den Knoten mit dem kleinsten Schlüssel im durch root festgelegten aum oder Teilbaum. Lösung 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. Das Maximum kann analog gefunden werden. DSL/SS 17 VL-10: inäre Suchbäume 17/43 DSL/SS 17 VL-10: inäre Suchbäume 18/43 bfragen im ST: Nachfolger (1) Problem Wir suchen den Nachfolger-Knoten von node, also den bei Inorder-Traversierung als nächstes zu besuchenden Knoten. Der Schlüssel des Nachfolgers ist mindestens so gross wie node.key. Lösung bfragen im ST: Nachfolger (1) Problem Wir suchen den Nachfolger-Knoten von node, also den bei Inorder-Traversierung als nächstes zu besuchenden Knoten. Der Schlüssel des Nachfolgers ist mindestens so gross wie node.key. Lösung Der rechte Teilbaum existiert: Nachfolger ist kleinster Knoten im rechten Teilbaum. node 1 Der rechte Teilbaum existiert: Nachfolger ist kleinster Knoten im rechten Teilbaum. ndernfalls: Nachfolger ist nächster Vorfahre, dessen linker Teilbaum node enthält. node 1 Komplexität: Θ(h) bei aumhöhe h. Der Vorgänger kann analog gefunden werden. DSL/SS 17 VL-10: inäre Suchbäume 19/43 DSL/SS 17 VL-10: inäre Suchbäume 19/43

6 bfragen im ST: Nachfolger (2) Der rechte Teilbaum existiert: Nachfolger ist kleinster Knoten im rechten Teilbaum. ndernfalls: Nachfolger ist nächster Vorfahre, dessen linker Teilbaum node enthält. Ersetzen & ustauschen 1 Node bstsucc ( Node node ) { // node!= null 2 if ( node. right ) { 3 return bstmin ( node. right ); 4 } // bbruch, wenn node nicht mehr rechtes Kind // oder wenn node. parent leer 7 while ( node. parent && node. parent. right == node ) { 8 node = node. parent ; 9 } 10 return node. parent ; 11 } DSL/SS 17 VL-10: inäre Suchbäume /43 DSL/SS 17 VL-10: inäre Suchbäume 21/43 Ersetzen von Teilbäumen im ST ustauschen von Knoten im ST 1 // Ersetzt im aum t den Teilbaum old durch 2 // den Teilbaum node ( ohne Sortierung!) 3 void bstreplace ( Tree t, Node old, Node node ) { 4 if ( node ) { // erlaube node == null! node. parent = old. parent ; } 7 if (! old. parent ) { // war die Wurzel 8 t. root = node ; 9 } else if ( old == old. parent. left ) { 10 // war linkes Kind 11 old. parent. left = node ; 12 } else { // rechtes Kind 13 old. parent. right = node ; 14 } } 1 // Tauscht den Knoten old gegen node aus ; 2 // die Kinder von old sind weiterhin im ST! 3 void bstswap ( Tree t, Node old, Node node ) { 4 // uebernimm linken Teilbaum node. left = old. left ; // auch moeglich : swap () if ( node. left ) { 7 node. left. parent = node ; 8 } 9 // rechten Teilbaum 10 node. right = old. right ; 11 if ( node. right ) { 12 node. right. parent = node ; 13 } 14 // fuege den Knoten ein bstreplace (t, old, node ); 1 } Das Ersetzen eines Teilbaums hat Zeitkomplexität Θ(1). Das ustauschen eines Knotens hat Zeitkomplexität Θ(1). DSL/SS 17 VL-10: inäre Suchbäume 22/43 DSL/SS 17 VL-10: inäre Suchbäume 23/43

7 Löschen im ST: Die beiden einfachen Fälle 1 1 Löschen 10 1 DSL/SS 17 VL-10: inäre Suchbäume 24/43 DSL/SS 17 VL-10: inäre Suchbäume 2/43 Löschen im ST: Der aufwändigere Fall Löschen im ST: Strategie 1 1 Löschen Um Knoten node aus dem ST zu löschen, verfahren wir folgendermassen: Fall 1: node hat keine Kinder: Ersetze im Vaterknoten von node den Zeiger auf node durch null Fall 2: node hat ein Kind: Wir schneiden node aus, indem wir den Vater und das Kind direkt miteinander verbinden (den Teilbaum ersetzen). 1 Fall 3: node hat zwei Kinder: Wir finden den Nachfolger von node, entfernen ihn aus seiner ursprünglichen Position und tauschen node gegen den Nachfolger. Es tritt nur der erste Fall (bstmin(node.right)) aus bstsucc auf. Der gesuchte Nachfolger hat kein linkes Kind. DSL/SS 17 VL-10: inäre Suchbäume 2/43 DSL/SS 17 VL-10: inäre Suchbäume 27/43

8 Löschen im ST: lgorithmus Komplexität der Operationen auf STs 1 // Entfernt node aus dem aum. 2 // Danach kann node ggf. aus Speicher entfernt werden 3 void bstdel ( Tree t, Node node ) { 4 if ( node. left && node. right ) { // zwei Kinder Node tmp = bstmin ( node. right ); bstdel (t, tmp ); // hochstens ein Kind, rechts 7 bstswap (t, node, tmp ); 8 } else if ( node. left ) { // ein Kind, links 9 bstreplace (t, node, node. left ); 10 } else { // ein oder kein Kind ( node. right == null ) 11 bstreplace (t, node, node. right ); 12 } 13 } Operation bstsearch bstsucc bstmin bstins bstdel Zeit Θ(h) Θ(h) Θ(h) Θ(h) Θ(h) lle Operationen sind linear in der Höhe h des STs Die Höhe ist log 2 n, falls der aum nicht allzu unbalanziert ist Ein binärer aum kann mittels Rotationen wieder balanziert werden DSL/SS 17 VL-10: inäre Suchbäume 28/43 DSL/SS 17 VL-10: inäre Suchbäume 29/43 Zufällig erzeugte binäre Suchbäume Zufällig erzeugter ST Ein zufällig erzeugter ST mit n Elementen ist ein ST, der durch das Einfügen von n Schlüsseln in zufälliger Reihenfolge in einen anfangs leeren aum entsteht. nnahme: Jede der n! möglichen Einfügungsordnungen hat gleiche Wahrscheinlichkeit. Rotationen & VL-äume Theorem (ohne eweis) Die erwartete Höhe eines zufällig erzeugten STs mit n Elementen beträgt O(log n). Fazit: Im Schnitt verhält sich ein binärer Suchbaum wie ein (fast) balanzierter Suchbaum. DSL/SS 17 VL-10: inäre Suchbäume 30/43 DSL/SS 17 VL-10: inäre Suchbäume 31/43

9 leftrotate: Konzept und eispiel Rotationen: Eigenschaften und Komplexität 1 leftrotate(1) 2 1 rightrotate(2) 2 1 leftrotate(1) 2 1 rightrotate(2) 2 eispiel 13 leftrotate() Lemma Ein rotierter ST ist wieder ein ST Die Inorder-Traversierung beider äume bleibt unverändert Zeitkomplexität Die Zeitkomplexität für Links- oder Rechtsrotieren ist in Θ(1). DSL/SS 17 VL-10: inäre Suchbäume 32/43 DSL/SS 17 VL-10: inäre Suchbäume 33/43 leftrotate: lgorithmus 1 void leftrotate ( Tree t, Node node1 ) { 2 // voellig analog : rightrotate () 3 Node node2 = node1. right ; 4 // aum verschieben node1. right = node2. left ; if ( node1. right ) { 7 node1. right. parent = node1 ; 8 } 9 // node2 wieder einhaengen 10 node2. parent = node1. parent ; 11 if (! node1. parent ) { // node1 war die Wurzel 12 t. root = node2 ; 13 } else if ( node1 == node1. parent. left ) { 14 node2. parent. left = node2 ; } else { // war rechtes Kind 1 node2. parent. right = node2 ; 17 } 18 // node1 einhaengen 19 node2. left = node1 ; node1. parent = node2 ; 21 } VL-äume Definition: VL-aum Ein VL-aum ist balanzierter ST, bei dem sich für jeden Knoten die Höhen der beiden Teilbäume um höchstens 1 unterscheiden. ei VL-äumen wird Höhe der Teilbäume der Knoten balanziert. Dazu wird (in einem zusätzlichem Datenfeld) in jedem Knoten über die Höhe des Unterbaums uch geführt. Nach jeder Operation wird die alance wiederhergestellt. Dies ist in Θ(h) möglich! Dadurch bleibt stets h Θ(log n), und Θ(log n) kann für alle Operationen auf dem ST garantiert werden. Georgy delson-velsky ( ): Sowjetisch/Israelischer Mathematiker Evgenii Landis ( ): Sowjetischer Mathematiker n algorithm for the organization of information, Proceedings of the USSR cademy of Sciences, 192 DSL/SS 17 VL-10: inäre Suchbäume 34/43 DSL/SS 17 VL-10: inäre Suchbäume 3/43

10 VL-äume: alanzieren nach Einfügen (1) Jeder VL-aum ist (höhen)balanziert. Für alle Knoten x gilt: VL-äume: alanzieren nach Einfügen (2) Sei der tiefste unbalanzierte Knoten auf dem Pfad von Wurzel zum neu eingefügten Knoten (unbalanziert: linke Teilbaumhöhe rechte Teilbaumhöhe = ±2) rechte Teilbaumhöhe linke Teilbaumhöhe 1 }{{} balance(x) RR: Linksrotation auf : Falls wir einen neuen Knoten in den aum einfügen, so kann der aum dadurch unbalanziert werden. Rechter Teilbaum ist größer: Zwei Fälle RR und RL Rechtsrotation auf : Linksrotation auf : Die alance wird dann durch Rotation wieder hergestellt. Einfachrotation, wenn die tieferen lätter außen liegen. RL: Zwei analoge Fälle: Doppelrotation, wenn die tieferen lätter innen liegen. Rechtsrotation auf : Linksrotation auf : DSL/SS 17 VL-10: inäre Suchbäume 3/43 DSL/SS 17 VL-10: inäre Suchbäume 37/43 VL-äume: alanzieren nach Einfügen (3) VL-äume: alanzieren nach Einfügen (4a) Sei der tiefste unbalanzierte Knoten auf dem Pfad von Wurzel zum neu eingefügten Knoten (unbalanziert: linke Teilbaumhöhe rechte Teilbaumhöhe = ±2) Linker Teilbaum ist größer: Zwei Fälle LL und LR LL: Rechtsrotation auf : Linksrotation auf : Rechtsrotation auf : 1 void VLIns ( Tree t, Node node ) { 2 bstins (t, node ); 3 // Node deepestunbalancednode ( Tree t, Node node ) 4 // gibt null zurueck wenn t balanziert ist // und den tiefsten unbalanzierten Knoten in t sonst // ( der Parameter node wird zur effizienten 7 // Implementierung verwendet ) 8 Node = deepestunbalancednode (t, node ); 9 if (!= null ) balance (t, ); 10 } LR: Zwei analoge Fälle: Linksrotation auf : Rechtsrotation auf : DSL/SS 17 VL-10: inäre Suchbäume 38/43 DSL/SS 17 VL-10: inäre Suchbäume 39/43

11 VL-äume: alanzieren nach Einfügen (4b) 1 void balance ( Tree t, Node ){ 2 // ist tiefster unbalanzierter 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 { 10 if ( height (. right. right ) >= height (. right. left )) { 11 // RR 12 leftrotate (t, ); 13 } else { // RL 14 rightrotate (. right ); leftrotate (); } 1 } 17 } VL-äume: alanzieren nach Löschen aumhöhe von nach Rotation = aumhöhe vor Einfügen des neuen Knotens Ergo: Nach alanzieren von ist der gesamte aum wieder balanziert. uch das Löschen eines Knotens kann Unbalanziertheit verursachen: Die alanzierung des tiefsten unbalanzierten Knotens kann auf analoge Weise wie beim Einfügen erreicht werden. ber: der Teilbaum hat danach nicht mehr die gleiche Höhe wie vor dem Löschen (die Höhe ist um 1 kleiner geworden)! Im schlimmsten Fall müssen dann alle unbalanzierten Knoten einzeln balanziert werden. Da aber (1) die alanzierung eines Knotens nur konstanten ufwand erfordert und es (2) nur O(log n) unbalanzierte Knoten geben kann, ist der Gesamtaufwand immer noch logarithmisch. DSL/SS 17 VL-10: inäre Suchbäume 40/43 DSL/SS 17 VL-10: inäre Suchbäume 41/43 VL-äume: alanzieren nach Löschen Organisatorisches 1 void VLDel ( Tree t, Node node ) { 2 bstdel (t, node ); 3 // Node deepestunbalancednode ( Tree t, Node node ) 4 // gibt null zurueck wenn t balanziert ist // und den tiefsten unbalanzierten Knoten in t sonst //( der Parameter node wird zur effizienten 7 // Implementierung verwendet ) 8 Node = deepestunbalancednode (t, node ); 9 while (!= null ) { 10 // bool balanced ( Tree t, Node ) 11 // gibt true zurueck wenn balanziert ist in t 12 // und false sonst 13 if (! balanced (t, )) { 14 balance (t, ); =. parent. parent ; 1 } else { 17 =. parent ; 18 } 19 } } Nächste Vorlesung: Dienstag, Mai 23, 10: 11:4 Uhr, ula 1 Webseite: DSL/SS 17 VL-10: inäre Suchbäume 42/43 DSL/SS 17 VL-10: inäre Suchbäume 43/43