Grundlagen der Informatik 2 (GdI2) - Algorithmen und Datenstrukturen - 5) Suchverfahren Prof. Dr. Anja Schanzenberger FH Augsburg, Fakultät für Informatik Kontakt: anja.schanzenberger@hs-augsburg.de http://www.hs-augsburg.de/schanzenberger Sommer Semester 2008 (Stand: 16.03.2008) Studiengang Bachelor Informatik (Ibac2), Hochschule Augsburg, 2008 Die vorliegenden Unterlagen zur Vorlesung GdI Teil 2 dürfen nur verwendet werden für Studienzwecke durch Studierende der FH Augsburg.
Gliederung 1. Symboltabellen 1. Abstrakter Datentyp für Symboltabellen 2. Schlüsselindizierte Suche 3. Sequenzielle Suche 4. Binäre Suche 2. Binäre Suchbäume 3. Ausgeglichene Bäume 1. AVL-Bäume 2. Randomisierte binäre Suchbäume 3. Splay binäre Suchbäume 4. Top-Down 2-3-4 Bäume 5. Rot-Schwarz Bäume 6. Skiplisten 7. B-Bäume 8. B*/B Bäume 9. Amerikanische B*-Bäume 2
Lernziel Welche Möglichkeiten kennen Sie doppelte Schlüssel in einer Symboltabelle zu halten und wann würden Sie die Verwendung einer Möglichkeit empfehlen? Warum führt man Rotationen in binären Suchbäumen aus und welche Arten davon haben Sie kennen gelernt? Warum benötigt man bei rot-schwarz Bäumen eine Transformation von 4er-Knoten, wobei es in diesen Bäumen nur 2-er Knoten gibt? 3
1. Symboltabellen (1) Suchen bezeichnet man als das Abrufen bestimmter Informationseinheiten aus größeren vorher gespeicherten Datenbeständen Verfahren zum Suchen in Dateien (Files) die Elemente (Items) enthalten Elemente enthalten Schlüssel (Keys) und Informationen (Values, Data, Datensätze,...) Ziele der Suche: Elemente finden, die mit dem gegebenen Suchschlüssel übereinstimmen Ergebnis ist normalerweise die Information die zu einem gefundenem Schlüssel gespeichert ist 4
1. Symboltabellen (2) Eine Symboltabelle ist eine Datenstruktur von Elementen mit Schlüsseln, die zwei grundsätzliche Operationen unterstützen: Insert: Einfügen eines neuen Elements Search: Zurückgeben eines Elements mit einem gegebenen Schlüssel Andere Bezeichnung: Dictionary ( de: Wörterbuch) Weitere wichtige Operationen: Remove: Elemente entfernen Change: Elemente ändern Select: Auswählen des k-größten Elements Sort: Sortieren der Symboltabelle (Elemente in Reihenfolge der Schlüssel anzeigen) Join: Zwei Symboltabellen zu einer zusammenfassen Standard: Konstruieren, Testen ob leer, Zerstören, Kopieren 5
1.1 ADT für Symboltabellen (1) ADT für Elemente Implementierung Item.cxx #include <iostream.h> #include <stdlib.h> static int maxkey=1000; typedef int Key; class Item { private: Key keyval; float info; public: Item() { keyval = maxkey;} Key key() { return keyval;} }; int null() { return keyval == maxkey; } void rand() { keyval=1000*::rand()/rand_max; info=1.0*rand()/rand_max; } int scan (istream& is = cin) { return (is>>keyval>>info)!=0; } void show (ostream& os = cout) { os<<keyval<< <<info<<endl;} ostream& operator<<(ostream& os, Item& x) { x.show(os); return os; 6
1.1 ADT für Symboltabellen (2) ADT für Symboltabellen Schnittstelle ST.cxx template <class Item, class Key> class ST { private: //Implementierungsabhaengiger Code public: ST(int); int count(); //Elemente zaehlen Item search(key); void insert (Item); void remove (Item); Item select(int); //k-kleinstes Element auswaehlen void show(ostream&); }; 7
1.1 ADT für Symboltabellen (3) Möglichkeiten mit doppelten Schlüsseln (=mehrere Suchtreffer) Abweisen doppelter Schlüssel Primäre Datenstruktur verwenden In einer Datenstruktur auch die doppelten Schlüssel speichern Bei Suche: Rückgabe einer Liste von Elementen Primäre Datenstruktur verwenden und Kennzeichner In einer Datenstruktur auch die doppelten Schlüssel speichern Bei Suche: Suche nach gegebenem Schlüssel und Kennzeichner. Rückgabe einer Liste von Elementen Primäre und sekundäre Datenstruktur verwenden In primärer Datenstruktur nur erstes Vorkommen eines mehrfach vorkommenden Elements speichern In sekundärer Datenstruktur zu einem Schlüssel alle weiteren Elemente speichern Vorteil: Alle Elemente lassen sich mit nur einem Such-Aufruf zurückgeben und mit nur einem Entfernen-Aufruf entfernen 8
1.1 ADT für Symboltabellen (4) Symboltabellen Clientprogramm Suche von zufällig generierten oder von stdin eingelesenen eindeutigen Schlüsseln Clientprogramm #include <iostream.h> #include <stdlib.h> #include Item.cxx #include ST.cxx int main (int argc, char *argv[]) { int N, maxn = atoi(argv[1]); sw = atoi(argv[2]); ST<Item,Key> st(maxn); for (N=0; N<maxN; N++) { Item v; if (sw) v.rand(); else if (!v.scan()) break; if (!(st.search(v.key())).null()) continue; st.insert(v); } } st.show(cout); cout <<endl; cout <<N<< Key <<endl; cout<<st.count()<< eindeutige Schlüssel <<endl; Zufällige Keys oder von stdin eingelesen Durch search feststellen of Key schon vorhanden ist; Falls nicht dann insert 9
1.1 ADT für Symboltabellen (5) Leistungsdaten Suchen, Einfügen, Entfernen und Auswählen für zufällige Schlüssel: T avg log n Weitere berühmte Operationen für Symboltabellen: Fingersuche: Neue Suche beginnt an Punkt an dem alte Suche aufgehört hat Bereichssuche: Alle Knoten innerhalb eines Intervalls zählen oder anzeigen Suche des nächsten Nachbarn: Elemente mit Schlüsseln suchen die einem gegebenen Schlüssel am nächsten liegen 10
1.2 Schlüsselindizierte Suche (1) Eigenschaften Schlüsselwerte sollten eindeutige, kleine Zahlen sein Elemente werden in einem Array gespeichert Array wird durch die Schlüssel indiziert Ergebnis: Schlüsselindizierte arraybasierte Symboltabelle Initialisieren: Operator new[] initialisiert alle Einträge mit nullitem 11
1.2 Schlüsselindizierte Suche (2) Eigenschaften Einfügen: fügt Element mit Schlüsselwert k ein, indem es dies in st[k] speichert Suchen: Sucht nach Element mit Schlüsselwert k, indem es den Wert aus st[k] zurückgibt Entfernen: Element mit Schlüsselwert k wird entfernt, indem nullitem in st[k] geschrieben wird Auswählen, Sortieren, Zählen: Lineares Durchsuchen des Arrays, wobei Nullelemente übersprungen werden 12
1.2 Schlüsselindizierte Suche (3) Schlüsselindizierte arraybasierte Symboltabelle Schlüssel mit pos. Ganzzahlen kleiner als Markierungsschlüssel M Schnittstellenimplementierung ST.cxx void insert (Item x) { template <class Item, class Key> class ST { private: Item nullitem, *st; int M; public: ST(int maxn) { M=nullItem.key(); st= new Item[M]; } int count() { //Elemente zaehlen int N=0; for (int i=0; i<m; i++) if (!st[i].null()) N++; return N; } Item search(key v) { return st[v]; } } st[x.key()] = x; } void remove (Item) { st[x.key()]=nullitem; } Item select(int k) { for (int i=0; i<m; i++) if (!st[i].null()) if (k--==0) return st[i]; return nullitem; } void show(ostream& os) { for (int i=0; i<m; i++) if (!st[i].null() st[i].show(os); } 13
1.2 Schlüsselindizierte Suche (4) Leistungsdaten Schlüsselwerte: 0 bis M-1 Anzahl Elemente: N Bedingung für die Schlüssel: N<=M Wenn M groß ist, müssen die Kosten für den erforderlichen Speicherplatz berücksichtigt werden Wenn N << M, dann sind die Kosten für die Zeit die der ST- Konstruktor benötigt, zu berücksichtigen Suchen und Einfügen lassen sich kaum effizienter implementieren Suchen, Einfügen und Entfernen: Benötigen konstante Laufzeit: O(c) Initialisieren, Auswählen und Sortieren: Laufzeit wächst proportional zu M, wenn eine der Operationen auf eine Tabelle mit N Elementen ausgeführt wird: O(n) 14
1.3 Sequenzielle Suche (1) Eigenschaften Schlüsselwerte umfassen großen Zahlenbereich Elemente werden in einem Array gespeichert Elemente werden sortiert und hintereinander im Array gespeichert Einfügen: Verschieben der größeren Elemente um eine Position nach hinten (Sortieren durch Einfügen) Suche: Sequenzielles Durchlaufen des Arrays; Suchfehler kann festgestellt werden sobald Schlüssel gefunden wird der größer wie der Suchschlüssel ist 15
1.3 Sequenzielle Suche (2) Arraybasierte Symboltabelle (geordnet) Schnittstellenimplementierung ST.cxx Item search(key v) { template <class Item, class Key> class ST { private: Item nullitem, *st; int N; public: ST(int maxn) { st=new Item[maxN+1]; N=0; } int count() { return N; } } for (int i=0; i<n; i++) if (!(st[i].key() < v)) break; if (v == st[i].key()) return st[i]; return nullitem; } void insert (Item x) { int i=n++; Key v=x.key(); while (i>0 && v<st[i-1].key()) { st[i]=st[i-1]; i++; } st[i]=x; } Item select(int k) { return st[k]; } void show(ostream& os) { int i=0; while (i<n) st[i++].show(os); } 16
1.3 Sequenzielle Suche (3) Alternativen Geordnetes Array Neues Element einsortieren Einfügen: Langsamer durch verschieben größerer Elemente Suchen: sequentiell Durchsuchen bis Schlüssel gefunden oder Schlüssel größer sind Ungeordnet Array Neues Element am Ende anhängen Einfügen: sehr schnell Suchen: sequentiell Durchsuchen bis Ende Auswählen und Sortieren laufen langsamer Entfernen: Element suchen, letztes Element im Array an die Position verschieben, Größe des Arrays dekrementieren 17
1.3 Sequenzielle Suche (4) Auf verketteter Liste basierende Symboltabelle (ungeordnet) Schnittstellenimplementierung ST.cxx Item searchr(link t; Key v) { #include <stdlib.h> if (t==0) return nullitem; template <class Item, class Key> if (t->item.key() == v) class ST { return t->item; private: return searchr(t->next,v); Item nullitem; } struct node { public: Item item; node *next; ST(int maxn) { node(item x, node *t) { head=0; N=0; } item=x; next=t; } int count() { }; return N; } typdef node *link; Item search(key v) { int N; return searchr(head,v); } link head; void insert (Item x) { head=new node(x,head); N++; } }; 18
1.3 Sequenzielle Suche (5) Alternativen Array Maximale Größe des Arrays muss im Voraus bekannt sein Geordnet und Ungeordnet möglich Verkettete Liste Maximale Größe der verketteten Liste muss nicht im Voraus bekannt sein Geordnet und Ungeordnet möglich Benötigt zusätzlichen Speicherplatz für die Verbindungen Auswählen (Select) ist nicht effizient implementierbar Effizientes Verknüpfen und Entfernen 19
1.3 Sequentielle Suche (6) Leistungsdaten Ungünstigster Fall Durchschnittlicher Fall Auswählen Einfügen Suche n Einfügen Suchtreffer Suchfehler Schlüsselindiziertes Array 1 1 M 1 1 1 Geordnetes Array N N 1 N/2 N/2 N/2 Geordnete verkettete Liste N N N N/2 N/2 N/2 Ungeordnetes Array 1 N N lg N 1 N/2 N Ungeordnete verkettete Liste 1 N N lg N 1 N/2 N 20
1.4 Binäre Suche (1) Eigenschaften Teile-und-herrsche Verfahren Menge der Elemente wird in zwei Teile zerlegt Bestimmt wird zu welcher Menge der Suchschlüssel gehört; dann wird mit diesem Teil weiter gearbeitet Elemente sind sortiert Es werden Indizes auf das sortierte Array verwendet, um den Teil des Arrays einzugrenzen, mit dem weiter gearbeitet wird Es gibt rekursive und nicht-rekursive Variante (siehe Einführungskapitel 1) 21
1.4 Binäre Suche (2) Binäre Suche für arraybasierte Symboltabelle Kein Stack erforderlich, weil die rekursive Funktion in einem rekursiven Aufruf endet Teil der Schnittstellenimplementierung ST.cxx private: Item searchr (int l, int r, Key v) { if (l>r) return nullitem; int m=(l+r)/2; if (v==st[m].key()) return st[m]; if (l==r) return nullitem; if (v<st[m].key()) return searchr(l,m-1,v); else return searchr(m+1,r,v); } public: Item search(key v) { return searchr(0,n-1,v); } 22
1.4 Binäre Suche (3) Beispiele Gesucht: 73 1 2 25 38 39 44 56 71 73 79 88 91 94 98 99 73 79 88 91 94 98 99 73 79 88 73 Wieviele Iterationen werden bei 200 Elementen benötigt? 7 Iterationen: 200, 99, 49, 24, 11, 5, 2, 1 Jede Iteration ist etwas kleiner als die Hälfte der vorhergehenden 23
1.4 Binäre Suche (4) Leistungsdaten Ungünstigster Fall Durchschnittlicher Fall Auswählen Einfügen Suche n Einfügen Suchtreffer Suchfehler Binäre Suche N lg N 1 N/2 lg N Lg N 24
2. Binäre Suchbäume (1) Eigenschaften Löst das Problem das Einfügeoperationen teuer sind Symboltabelle wird auf expliziter Baumstruktur aufgebaut Schnelle Operationen Suchen, Einfügen, Auswählen und Sortieren möglich Gutes Verfahren das zu den elementarsten Algorithmen in der Informatik zählt Ein binärer Suchbaum (engl. BST: binary search tree) ist ein Binärbaum, bei dem jeder interne Knoten mit einem Schlüssel verbunden ist Ein Schlüssel in einem beliebigen Knoten ist größer (oder >=) als alle Schlüssel in Knoten aus seinem linken Teilbaum, und kleiner (oder <=) alle Schlüssel in Knoten aus seinem rechten Teilbaum 25
2. Binäre Suchbäume (2) Auf binärem Suchbaum basierende Symboltabelle Search und Insert rufen die privaten rekursiven Funktionen auf Head zeigt auf die Wurzel im Baum Schnittstellenimplementierung ST.cxx template <class Item, class Key> class ST { private: struct node { Item item; node *l, *r; node (Itemx) { item=x; l=0; r=0; } }; typedef node *link; link head; Item nullitem; Item searchr(link h, Key v) { if (h==0) return nullitem; Key t= h->item.key(); if (v==t) return h->item; if (v<t) return searchr(h->l, v); else return searchr(h->r, v); } void insertr(link& h, Item x) { if (h==0) {h=new node(x); return; } if (x.key() < h->item.key()) insertr(h->l, x); else insertr(h->r, x); } 26
2. Binäre Suchbäume (3) Auf binärem Suchbaum basierende Symboltabelle }; Schnittstellenimplementierung ST.cxx public: ST(int maxn) {head=0; } Item search(key v) { return searchr (head, v); } void insert(item x) { insertr (head, x); } Die Suchoperation stoppt wenn entweder ein Element mit dem Suchschlüssel gefunden ist (Suchtreffer) oder der aktuelle Teilbaum leer ist (Suchfehler) 27
2. Binäre Suchbäume (4) Beispiel Erfolgreiche Suche nach Schlüssel 8 1 19 5 25 3 18 8 7 9 14 28
2. Binäre Suchbäume (5) Beispiel Erfolglose Suche nach Schlüssel 13 1 19 5 25 3 18 8 7 9 14 29
2. Binäre Suchbäume (6) Beispiel Einfügen von Schlüssel 13 (links von 14) 1 19 5 25 3 18 8 7 9 13 14 30
2. Binäre Suchbäume (7) Konstruktion eines binären Suchbaums Sequenz: 1, 19, 5, 18, 3, 8, 9, 14, 7, 25, 13, 16, 12 1 1 4 1 1 6 7 1 2 1 19 5 19 18 3 5 19 18 3 5 19 18 3 1 5 19 5 1 5 19 8 8 9 3 18 31
2. Binäre Suchbäume (8) Konstruktion eines binären Suchbaums Sequenz: 1, 19, 5, 18, 3, 8, 9, 14, 7, 25, 13, 16, 12 8 1 9 1 10 1 19 19 19 5 5 5 25 3 18 3 18 3 18 8 8 8 9 7 9 7 9 14 14 14 32
2. Binäre Suchbäume (9) Konstruktion eines binären Suchbaums Sequenz: 1, 19, 5, 18, 3, 8, 9, 14, 7, 25, 13, 16, 12 11 1 12 1 13 1 19 19 19 5 25 5 25 5 25 3 18 3 18 3 18 8 8 8 7 9 7 9 7 9 14 14 14 13 13 16 13 16 12 33
2. Binäre Suchbäume (10) Sortieren mit binärem Suchbaum Elemente in Reihenfolge ihrer Schlüssel anzeigen Traversieren in Inorder-Reihenfolge genügt in diesem Fall Elemente im linken Teilbaum (rekursiv) ausgeben Dann die Wurzel Anschließend die Elemente im rechten Teilbaum (rekursiv) ausgeben private: void showr (link h, ostream&os) { if (h==0) return; showr(h->l, os); h->item.show(os); showr(h->r.os); } public: void show (ostream&os) { showr(head, os); } 34
2. Binäre Suchbäume (11) Einfügen in binären Suchbaum (nicht-rekursiv) Suchfehler finden, worauf die leere Verbindung durch einen Zeiger auf den neuen Knoten ersetzt wird Vorgänger p des aktuellen Knoten k festhalten Unten angelangt zeigt p auf den Knoten, dessen Verbindung auf den neuen Knoten zeigen muss void insert (Item x ) { Key v=x.key(); if (head==0) {head=new node(x); return;} link p=head; for (link q=p; q!=0; p=q?q:p) q=(v<q->item.key())? q->l : q->r; if (v < p->item.key()) p->l = new node(x); else p->r = new node(x); } 35
2. Binäre Suchbäume (12) Leistungsdaten Laufzeiten von Algorithmen auf binäre Suchbäume sind von der Gestalt der Bäume abhängig Bester Fall: Baum vollständig ausgeglichen mit ld N Knoten zwischen Wurzel und jedem externen Knoten Ungünstigster Fall: N Knoten in jedem Suchpfad; Baumhöhe bestimmt die Kosten einer Suche Durchschnittlicher Fall: logarithmische Suchzeit Ungünstigster Fall Durchschnittlicher Fall Auswählen Einfügen Suche n Einfügen Suchtreffer Suchfehler Binäre Suchbaum N N N Lg N lg N Lg N 36
2. Binäre Suchbäume (13) Beispiel: binärer Suchbaum Einfügen von ca. 200 zufällige Schlüsseln in einen anfangs leeren Baum Gut ausgeglichen und wächst eher in die Breite als in die Höhe Keine Suche benötigt mehr als 12 Vergleiche Die durchschnittlichen Kosten für einen Suchtreffer betragen ungefähr 10 37
2. Binäre Suchbäume (14) Beispiele für ungünstige Fälle 1 1 2 3 8 4 5 - Schlüssel treffen in aufsteigender Reihenfolge ein - Binärer Suchbaum ist nicht gut ausgeglichen - Binärer Suchbaum entartet zu einfach verketteter Liste - quadratische Konstruktionszeit - lineare Suchzeit 2 3 6 7 - zufällig geordnete Schlüssel - Binärer Suchbaum ist dennoch nicht gut ausgeglichen 38
2. Binäre Suchbäume (15) Indeximplementierungen Eigenschaften Arraygröße muss im Voraus bekannt sein Genug Speicherplatz muss vorhanden sein Index: Eine zu den Elementen externe Suchstruktur, die schnellen Zugriff auf Elemente mit einem gegebenen Suchschlüssel bietet Drei Arrays: Elemente, die linken Verbindungen und die rechten Verbindungen Die Verbindungen sind Arrayindizes (Ganzzahlen) Verbindungsreferenzen wie x=x->l durch x=l[x] ersetzen Anwendung Schlüsselwortsuche in einem Textstring 39
2. Binäre Suchbäume (16) Beispiel 0 call me ishmael some... 5 me ishmael some year... 8 ishmael some year a... 16 some years ago never... 21 years ago never mind... 27 ago never mind how l... 31 never mind how long... 37 mind how long precis... 42 how long precisely h... 46 long precisely having... 51 precisely having lit...... 0 27 5 8 call 42 46 me 16 31 never 37 51 mind Suche: Ist never mind enthalten? - Stringschlüssel auf Beginn jedes Wortes (=Stringindex) - Erstellung des binären Suchbaums - Zugriff über Stringindex some 21 40
2. Binäre Suchbäume (17) Client für das Indizieren eines Textstrings mit binärem Suchbaum Item.cxx: char* für Stringschlüssel in Elementen überladener Operator< verwendet strcmp überladener Operator== verwendet strcmp Umwandlungsoperator von Item nach char* 41
2. Binäre Suchbäume (18) Client für das Indizieren eines Textstrings #include <iostream.h> #include <fstream.h> #include Item.cxx #include ST.cxx static char text[maxn]; int main (int argc, char *argv[]) { int N=0; char t; ifstream corpus; corpus.open(*++argv); while (N<maxN && corpus.get(t)) text[n++]=t; text[n]=0; ST<Item, Key> st(maxn); for (int i=0; i<n; i++) st.insert(&text[i]); char query[maxq]; Item x, v(query); while (cin.getline(query, maxq)) if ((x=st.search(v.key()).null()) cout << nicht gefunden: << query << endl; else cout <<x->text << : << query << endl; Prof. } Dr. A. Schanzenberger 42
2. Binäre Suchbäume (19) Leistungsdaten Suche: 2N ln N Vergleiche Bedeutung: Nachdem der Index erstellt ist kann man in ca. 1 Million Zeichen mit 30 Stringvergleichen jede Phrase im Text finden (z.b. Buch von Moby Dick) 43
2. Binäre Suchbäume (20) Leistungsdaten Empirische Ergebnisse für Implementierungen von Symboltabellen 44
2. Binäre Suchbäume (21) Einfügen an der Wurzel im binären Suchbaum Standardimplementierung war: Neu eingefügter Knoten ersetzt einen externen Knoten (unterste Baumebene) Alternative: Einfügen eines neuen Knoten an der Wurzel Zuletzt eingefügte Knoten befinden sich an der Spitze des Baums Zwei mögliche Fälle: Einzufügender Schlüssel ist... größer als Schlüssel an der Wurzel Einzufügender Schlüssel ist neuer Wurzelknoten Die alte Wurzel als linken Teilbaum nehmen Den rechten Teilbaum der alten Wurzel als rechten Teilbaum nehmen Problem: Rechter Teilbaum kann kleinere Schlüssel enthalten, so dass etwas mehr getan werden muss um das Einfügen abzuschließen kleiner als Schlüssel an der Wurzel Einzufügender Schlüssel ist neuer Wurzelknoten Die alte Wurzel als rechten Teilbaum nehmen Den linken Teilbaum der alten Wurzel als linken Teilbaum nehmen Problem: Linker Teilbaum kann größere Schlüssel enthalten, so dass etwas mehr getan werden muss um das Einfügen abzuschließen 45
2. Binäre Suchbäume (22) Einfügen an der Wurzel im binären Suchbaum Rotation Rolle der Wurzel und eines der Nachfolger der Wurzel in einem Baum vertauschen Die Ordnung des binären Suchbaums zwischen den Schlüsseln in den Knoten bleibt bewahrt Rechtsrotation: Wirkt auf die Wurzel und den linken Nachfolger Die Rotation bringt die Wurzel nach rechts und kehrt damit die Richtung der linken Verbindungen in der Wurzel um Linksrotation: Wirkt auf die Wurzel und den rechten Nachfolger Die Rotation bringt die Wurzel nach links und kehrt damit die Richtung der rechten Verbindungen in der Wurzel um 46
2. Binäre Suchbäume (23) Einfügen an der Wurzel im binären Suchbaum Rechtsrotation 3 5 7 1 8 12 19 18 9 25 14 13 16 1 3 7 5 8 12 18 19 9 14 25 13 16 Restbaum bleibt unverändert Rotation um Knoten 19: 19 geht nach unten und wird rechter Nachfolger seines vorherigen linken Nachfolgers Vorgehen: -Verbindung zur neuen Wurzel 5 von der linken Verbindung von 19 holen - Die linke Verbindung von 19 durch Kopieren der rechten Verbindung von 5 setzen - Die rechte Verbindung von 5 auf 19 setzen - Die rechte Verbindung von 1 nicht mehr auf 19 sondern auf 5 setzen 47
2. Binäre Suchbäume (24) Einfügen an der Wurzel im binären Suchbaum Linkssrotation 1 3 7 5 8 12 18 19 9 14 25 13 16 5 1 19 3 7 8 12 18 9 14 25 13 16 Restbaum bleibt unverändert Rotation um Knoten 1: 1 geht nach unten und wird linker Nachfolger seines vorherigen rechten Nachfolgers Vorgehen: -Verbindung zur neuen Wurzel 5 von der rechten Verbindung von 1 holen - Die rechte Verbindung von 1 durch Kopieren der linken Verbindung von 5 setzen - Die linke Verbindung von 5 auf 1 setzen - Die Kopfverbindung des Baums nicht mehr auf 1 sondern auf 5 zeigen lassen 48
2. Binäre Suchbäume (25) Einfügen an der Wurzel im binären Suchbaum Eigenschaften von Rotationen Lokale Änderung Beteiligt sind drei Verbindungen und zwei Knoten Knoten können im Baum verschoben werden ohne die globale Ordnung anzutasten Grund für Rotationen: Ausgeglichenheit von Bäumen aufrechterhalten 49
2. Binäre Suchbäume (26) Einfügen an der Wurzel im binären Suchbaum Implementierung von Rotationen im binären Suchbaum Rechtsrotation Macht die Wurzel zum rechten Teilbaum der neuen Wurzel void rotationr (link& h) { link x=h->l; h->l = x->r; x->r = h; h=x; } Linksrotation Macht die Wurzel zum linken Teilbaum der neuen Wurzel void rotationl (link& h) { link x=h->r; h->r = x->l; x->l = h; h=x; } 50
2. Binäre Suchbäume (27) Einfügen an der Wurzel im binären Suchbaum Konstruktion eines binären Suchbaums durch Einfügen an einem Blatt und rotieren bis zur Wurzel Einfügen von 7 1 1 2 1 3 1 19 19 19 5 25 5 25 5 25 3 18 3 18 3 7 7 8 7 8 8 18 51
2. Binäre Suchbäume (28) Einfügen an der Wurzel im binären Suchbaum Konstruktion eines binären Suchbaums durch Einfügen an einem Blatt und rotieren bis zur Wurzel Einfügen von 7 4 5 6 1 1 7 7 19 25 5 7 19 1 19 5 18 25 5 18 3 18 25 3 8 3 8 8 52
2. Binäre Suchbäume (29) Einfügen an der Wurzel im binären Suchbaum Implementierung der Konstruktion eines binären Suchbaums durch Einfügen an einem Blatt und rotieren bis zur Wurzel Einfügen eines neuen Elements an einem Blatt im geeigneten Teilbaum Durchführen der passenden (rekursiven) Rotation, um es zur Wurzel zu bringen private: void insertt (link& h, Item x) { if (h==0) { h=new node(x); return; } if (x.key() < h->item.key()) {insertt (h->l,x); rotationr(h); } else { insertt (h->r,x); rotationl(h);} } public: void insert (Item item) { insertt (head, item); } 53
2. Binäre Suchbäume (30) Einfügen an der Wurzel im binären Suchbaum Konstruktion eines binären Suchbaums durch Einfügen an der Wurzel Sequenz: 1, 19, 5, 18, 3, 8, 9 6 8 1 1 4 18 3 18 2 19 1 5 19 1 5 19 1 7 9 3 5 5 3 8 18 1 19 1 18 5 19 1 3 5 19 54
2. Binäre Suchbäume (31) Einfügen an der Wurzel im binären Suchbaum Konstruktion eines binären Suchbaums durch Einfügen an der Wurzel Einsatz in der Praxis: Verfahren hat den Vorteil, dass sich zuletzt eingefügte Schlüssel in der Nähe der Spitze befinden Kosten sind bei zuletzt eingefügten Schlüsseln eher geringer als bei Standardverfahren Oft bezieht sich ein großer Prozentsatz der Suchen auf Elemente die zuletzt eingefügt wurden Beispiel: Transaktionsverarbeitung bei dem aktive Transaktionen in der Nähe der Spitze bleiben 55
2. Binäre Suchbäume (32) Implementation anderer Funktionen: Auswählen Element mit k-kleinsten Schlüssel finden Für jeden Knoten muss die Teilbaumgröße mit gespeichert werden Anzahl Knoten im linken Teilbaum prüfen k Knoten enthalten: Wurzelelement zurückgeben Mehr wie k Knoten enthalten: rekursiv im linken Teilbaum prüfen Sonst: linker Teilbaum enthält t Elemente mit t<k. Das k-kleinste Element ist das (k-t-1)-kleinste Element im rechten Teilbaum private: Item selectr (link &h, int k) { if (h==0) return nullitem; int t = (h->l == 0)? 0: h->l->n; if (t>k) return selectr(h->l, k); if (t<k) return selectr(h->r, k-t-1); return h->item; } public: Item select (int k) { return selectr (head,k); } 56
2. Binäre Suchbäume (33) Implementation anderer Funktionen: Zerlegen Durch Zerlegen Element mit k-kleinsten Schlüssel finden Auswählen in Operation Zerlegen ändern Baum neu anordnen, um das k-kleinste Element zur Wurzel zu bringen Nach den rekursiven Aufrufen eine Rotation hinzufügen (siehe Beispiel wie bei: Konstruktion eines binären Suchbaums durch Einfügen an einem Blatt und rotieren bis zur Wurzel) private: Item partr (link& h, int k) { int t = (h->l == 0)? 0: h->l->n; if (t>k) {partr(h->l, k); rotationr(h); } if (t<k) {partr(h->r, k-t-1); rotationl(h); } } 57
2. Binäre Suchbäume (34) Implementation anderer Funktionen: Entfernen 1 Entfernen der Wurzel 7 1 19 5 18 25 3 1 8 19 5 18 Linke Verbindung muss leer sein 25 3 8 3 2 3 1 19 5 18 8 25 Kleinstes Element im rechten Teilbaum 4 3 1 8 19 5 18 25 58
2. Binäre Suchbäume (35) Implementation anderer Funktionen: Entfernen Entfernen der Wurzel Ansatz ist asymmetrisch und ad-hoc Warum muss kleinster Schlüssel im zweiten Baum genommen werden? Alternativen Größten Schlüssel im ersten Baum nehmen Falls der zu entfernende Konten eine linke Nullverbindung enthält kann man ihn zum rechten Nachfolger der neuen Wurzel machen Alle diese Verfahren sind subobtimal da... Zurückbleibender Baum ist nicht mehr zufällig auch wenn er vorher zufällig war Es bleiben unausgeglichene Bäume zurück (mit durchschnittlicher Höhe von der Wurzel aus N) 59
2. Binäre Suchbäume (36) Implementation anderer Funktionen: Entfernen Entfernen eines Knotens 1: Entfernen von 8 7 2: Entfernen von 19 7 1 19 1 19 5 18 25 5 18 25 3 8 3 7 1 19 5 18 25 3 Knoten wird einfach entfernt, da unterste Ebene 8 3 7 1 25 5 18 19 wird durch 25 ersetzt, da der linke Nachfolger von 25 leer ist 8 60
2. Binäre Suchbäume (37) Implementation anderer Funktionen: Entfernen Entfernen eines Knoten 3: Entfernen von 7 3 1 19 7 5 18 8 25 1 19 8 5 18 Knoten 18 hat linken Nachfolger, also wird Knoten 7 durch seinen Nachfolger Knoten 8 im Baum ersetzt 25 3 61
2. Binäre Suchbäume (38) Implementation anderer Funktionen: Entfernen Implementierung von Entfernen eines Knoten Methode entfernt den ersten Knoten mit Schlüssel v der gefunden wird Baum wird von oben nach unten durchgearbeitet rekursive Aufrufen für die Teilbäume bis sich der zu entfernende Knoten an der Wurzel befindet Knoten wird dann ersetzt durch Zusammenfügen beider Teilbäume Kleinster Knoten im rechten Teilbaum wird neue Wurzel und dessen linke Verbindung wird auf den linken Teilbaum gesetzt 62
2. Binäre Suchbäume (39) Implementation anderer Funktionen: Entfernen Implementierung von Entfernen eines Knoten private: link joinlr (link a, link b) { if (b==0) return a; partr (b, 0); b->l = a; return b; } void remover (link& h, Key v) { if (h==0) return; Key w = h->item.key(); if (v<w) remover(h->l, v); if (v>w) remover(h->r, v); if (v==w) { link t=h; h=joinlr(h->l, h->r); delete t; } } public: void remove (Item x) { remover (head, x.key()); } Es ist typisch für Suchalgorithmen, dass sie beträchtlich kompliziertere Implementierungen für das Entfernen als für das Suchen erfordern Abhilfemöglichkeiten: - Knoten zum Löschen nur markieren (lazy Ansatz) - Baum ab und zu neu aufbauen 63
2. Binäre Suchbäume (40) Implementation anderer Funktionen: Verknüpfen Mischen zweier binärer Suchbäume Alternativen Siehe nächste Folie Ersten Suchbaum traversieren und jeden Knoten in den zweiten Suchbaum einfügen Laufzeit: >linear, da jedes Einfügen linear erfolgen kann Beide Suchbäume traversieren, Element in ein Array übernehmen, die Elemente mischen und in einen neuen Suchbaum einfügen Laufzeit: Linear Speicherplatz: Array für alle Elemente Rekursive Impl.: Wurzel des ersten Suchbaums an der Wurzel des zweiten Suchbaums einfügen. Dies ergibt zwei Teilbäume mit Schlüsseln die größer als diese Wurzeln sind. Rekursiv wird das erste Paar als linker Teilbaum der Wurzel zusammengefasst; Rekursiv wird das zweite Paar als rechter Teilbaum der Wurzel kombiniert Laufzeit: linear, da jeder Knoten kann in einem rekursiven Aufruf höchstens einmal der Wurzelknoten sein 64
2. Binäre Suchbäume (41) Implementation anderer Funktionen: Verknüpfen Beispiel 7 14 1: 5 13 8 24 1 9 18 3 19 16 2: Zwei Teilbaumpaare mit neuer Wurzel 7 5 13 7 1 9 18 3 8 14 24 19 16 65
2. Binäre Suchbäume (42) Implementation anderer Funktionen: Verknüpfen Beispiel 3: Ergebnis 5 7 13 1 3 8 9 18 14 16 19 25 66
2. Binäre Suchbäume (43) Implementation anderer Funktionen: Verknüpfen Implementierung private: link joinr (link a, link b) { if (b==0) return a; //Leerer Suchbaum dann anderer ist das Ergebnis if (a==0) return b; insertt (b, a->item); //in zweiten Suchbaum neue Wurzel einfügen b->l = joinr(a->l, b->l); b->r = joinr(a->r, b->r); delete a; return b; } public: void join (ST<Item, Key>&b) { head = joinr (head, b.head); //Member head ist a } 67
2. Binäre Suchbäume (44) Implementation anderer Funktionen: Verknüpfen Alle diese Verfahren sind subobtimal da... Vorgang ist asymmetrisch Es bleiben unausgeglichene Bäume zurück 7 5 13 1 9 18 3 8 14 25 16 19 68
2. Binäre Suchbäume (45) Diskussion der Suchbäume Vorteile Garantiert hohe Leistung bei Suchen, Einfügen und Sortieren Auswählen, Entfernen, Verknüpfen: einfache rekursive Lösungen sind möglich Nachteile Speicherplatz für Verbindungen ist hoch (Alternative: Hashing-Verfahren) Entfernen und Verknüpfen: Möglichkeit besteht zu schlecht ausgeglichenen, asymmetrischen Suchbäumen Im ungünstigsten Fall zeigt sich eine schlechte Leistung 69