Algorithmen und Datenstrukturen Prof. Jürgen Sauer Algorithmen und Datenstrukturen Skriptum zur Vorlesung im SS 2008 1 Algorithmen und Datenstrukturen 2 Algorithmen und Datenstrukturen Inhaltsverzeichnis Literaturverzeichnis.............................................................................................................................................. 7 1. GRUNLEGENDE KONZEPTE............................................................................................................ 9 1.1 Die zentralen Begriffe ..................................................................................................................................... 9 1.2 Algorithmische Grundkonzepte................................................................................................................... 10 1.2.1 Algorithmenbegriffe ................................................................................................................................ 10 1.2.2 Terminierung und Determinismus ........................................................................................................... 10 1.2.3 Algorithmenbausteine .............................................................................................................................. 11 1.2.4 Paradigmen der Algorithmenbeschreibung.............................................................................................. 13 1.2.4.1 Applikative Algorithmen .................................................................................................................. 14 1.2.4.2 Imperative Algorithmen .................................................................................................................... 16 1.2.4.3 Objektorientierte Algorithmen .......................................................................................................... 16 1.2.4.4 Paradigmen und Programmiersprachen ............................................................................................ 19 1.2.5 Beschreibung von Algorithmen ............................................................................................................... 19 1.2.6 Formale Eigenschaften von Algorithmen ................................................................................................ 22 1.2.6.1 Korrektheit und Terminierung .......................................................................................................... 22 1.2.6.2 Effizienz............................................................................................................................................ 23 1.2.7 Komplexität.............................................................................................................................................. 25 1.2.7.1 Laufzeitberechnungen („Big-O“-) .................................................................................................... 28 1.2.7.2 O(logN)-Algorithmen ....................................................................................................................... 32 1.2.7.3 Berechnungsgrundlagen für rechnerische Komplexität .................................................................... 32 1.3 Daten und Datenstrukturen ......................................................................................................................... 35 1.3.1 Datentyp................................................................................................................................................... 35 1.3.2 Datenstruktur............................................................................................................................................ 37 1.3.3 Relationen und Ordnungen ...................................................................................................................... 42 1.3.4 Klassifikation von Datenstrukturen ......................................................................................................... 47 1.3.4.1 Lineare Ordnungsgruppen ................................................................................................................ 47 1.3.4.2 Nichtlineare Kollektion..................................................................................................................... 50 1.3.4.2.1 Hierarchische angeordnete Sammlung (Bäume)........................................................................ 50 1.3.4.2.2 Gruppenkollektionen.................................................................................................................. 55 1.3.4.3 Dateien und Datenbanken ................................................................................................................. 56 1.3.5 Definitionsmethoden für Datenstrukturen................................................................................................ 59 1.3.5.1 Der abstrakte Datentyp...................................................................................................................... 59 1.3.5.2 Die axiomatische Methode................................................................................................................ 60 1.3.5.3 Die konstruktive Methode................................................................................................................. 62 1.3.5.4 Die objektorientierte Modellierung abstrakter Datentypen............................................................... 63 1.3.5.6 Die Implementierung abstrakter Datentypen in Java ........................................................................ 71 1.3.5.6.1 Klassen und Schnittstellen (Referenzdatentypen)...................................................................... 71 1.3.5.6.2 Generische Typen ...................................................................................................................... 76 1.3.5.6.3 Wildcard-Typen ......................................................................................................................... 83 2. DATENSTRUKTUREN UND ALGORITHMEN IN JAVA ................................................................. 88 2.1 Kollektionen (Collections) ............................................................................................................................ 89 2.1.1 Durchwandern von Daten mit Iteratoren ................................................................................................. 89 2.1.2 Die Klasse Vector .................................................................................................................................... 89 2.1.3 Die Klasse Stack ...................................................................................................................................... 92 2.1.4 Die Klasse Bitset für Bitmengen.............................................................................................................. 94 2.1.5 Die Klasse Hashtable und assoziative Speicher....................................................................................... 95 2.1.6 Die abstrakte Klasse Dictionary............................................................................................................... 98 2.1.7 Die Klasse Properties ............................................................................................................................... 98 3 Algorithmen und Datenstrukturen 2.2 Das Collection Framework........................................................................................................................... 99 2.2.1 Die Schnittstellen Collection, Iterator, Comparator................................................................................. 99 2.2.2 Die Behälterklassen und Schnittstellen des Typs List ........................................................................... 102 2.2.3 Queues ................................................................................................................................................... 107 2.2.4 Behälterklassen des Typs Set................................................................................................................. 109 2.2.5 Behälterklassen des Typs Map............................................................................................................... 111 2.2.6 Algorithmen ........................................................................................................................................... 114 2.2.5.1 Datenmanipulation .......................................................................................................................... 114 2.2.5.2 Größter und kleinster Wert einer Collection................................................................................... 115 2.2.5.3 Sortieren.......................................................................................................................................... 115 2.2.5.4 Suchen von Elementen.................................................................................................................... 117 2.2.6 Generics ................................................................................................................................................. 118 2.2.6.1 Sammlungsklassen .......................................................................................................................... 118 2.2.6.2 Implementierung von Java Generics ............................................................................................... 120 2.2.6.2.1 Übersetzung von Generics ....................................................................................................... 120 2.2.6.2.2 Repräsentation von Generics im Laufzeitsystem ..................................................................... 120 2.2.7 Spracherweiterung in Java zur Iteration................................................................................................. 121 2.2.7.1 Erweiterte for-Schleife.................................................................................................................... 121 2.2.7.2 Das Interface Iterable ...................................................................................................................... 122 2.2.8 Implementierung von Graphen-Algorithmen zur Berechnung kürzester Wege mit Behälterklassen .... 124 2.2.8.1 Die Datenstrukturen Graph, Vertex, Edge zur Implementierung von Graphenalgorithmen für die Berechnung kürzester Wege ....................................................................................................................... 125 2.2.8.2 Kürzeste Pfade in gerichteten, ungewichteten Graphen.................................................................. 127 2.2.8.3 Berechnung der kürzesten Pfadlängen in gewichteten Graphen (Algorithmus von Dijkstra) ........ 131 2.2.8.4 Berechnung der kürzesten Pfadlängen in gewichteten Graphen mit negativen Kosten.................. 136 2.2.8.5 Berechnung der kürzesten Pfadlängen in gewichteten, azyklischen Graphen ................................ 137 3. ALGORITHMEN.............................................................................................................................. 138 3.1 Ausgesuchte algorithmische Probleme...................................................................................................... 138 3.1.1 Spezielle Sortieralgorithmen.................................................................................................................. 138 3.1.1.1 Interne Sortierverfahren .................................................................................................................. 138 3.1.1.1.1 Quicksort.................................................................................................................................. 138 3.1.1.1.2 Heap-Sort ................................................................................................................................. 140 3.1.1.1.3 Sortieren durch Mischen .......................................................................................................... 142 3.1.1.2 Externe Sortierverfahren ................................................................................................................. 145 3.1.1.2.1 Direktes Mischsortieren ........................................................................................................... 145 3.1.1.2.2 Natürliches Mischen ................................................................................................................ 149 3.1.2 Suche in Texten...................................................................................................................................... 152 3.1.2.1 String Pattern-Matching.................................................................................................................. 152 3.1.2.1.1 Ein einfacher Algorithmus zum Suchen in Zeichenfolgen ...................................................... 152 3.1.2.1.2 Der Algorithmus von Knuth-Morris-Pratt ............................................................................... 153 3.1.2.1.3 Boyer / Moore - Suche ............................................................................................................. 157 3.1.2.2 Pattern-Matching mit regulären Ausdrücken .................................................................................. 164 3.1.2.2.1 Reguläre Ausdrücke..................................................................................................................... 164 3.1.2.2.2 Überprüfung regulärer Ausdrücke mit endlichen Automaten.................................................. 167 3.1.2.2.3 Java 1.4 "regex" ....................................................................................................................... 171 3.2 Entwurfstechniken für Algorithmen (Einsatz von Algorithmen-Mustern)........................................... 174 3.2.1 Greedy Algorithmen .............................................................................................................................. 174 3.2.1.1 Greedy-Algorithmen für minimale Spannbäume ............................................................................ 175 3.2.1.2 Huffman Codes ............................................................................................................................... 178 3.2.2 Divide and Conquer ............................................................................................................................... 184 3.2.3 Induktiver Algorithmenentwurf und Dynamisches Programmieren ...................................................... 184 3.3 Rekursion..................................................................................................................................................... 186 3.3.1 Linear rekursive Funktionen .................................................................................................................. 186 3.3.2 Nichtlineare rekursive Funktionen......................................................................................................... 187 3.3.3 Primitive Rekursion ............................................................................................................................... 187 3.3.4 Nicht primitive Rekursion...................................................................................................................... 187 4 Algorithmen und Datenstrukturen 3.3.5 Rekursive Kurven .................................................................................................................................. 188 3.4 Backtracking-Algorithmen ........................................................................................................................ 193 3.5 Zufallsgesteuerte Algorithmen................................................................................................................... 197 4. BÄUME ........................................................................................................................................... 198 4.1 Grundlagen.................................................................................................................................................. 198 4.1.1 Grundbegriffe und Definitionen ............................................................................................................ 198 4.1.2 Darstellung von Bäumen........................................................................................................................ 199 4.1.3 Berechnungsgrundlagen......................................................................................................................... 200 4.1.4 Klassifizierung von Bäumen.................................................................................................................. 201 4.2 Freie Binäre Intervallbäume...................................................................................................................... 204 4.2.1 Ordnungsrelation und Darstellung ......................................................................................................... 204 4.2.2 Operationen............................................................................................................................................ 208 4.2.3 Ordnungen und Durchlaufprinzipien ..................................................................................................... 222 4.3 Balancierte Bäume ...................................................................................................................................... 228 4.3.1 Statisch optimierte Bäume ..................................................................................................................... 231 4.3.2 AVL-Baum ............................................................................................................................................ 232 4.3.3 Splay-Bäume.......................................................................................................................................... 243 4.4 Bayer-Bäume ............................................................................................................................................... 251 4.4.1 Grundlagen und Definitionen ................................................................................................................ 251 4.4.1.1 Ausgeglichene T-äre Suchbäume (Bayer-Bäume) .......................................................................... 251 4.4.1.2 (a,b)-Bäume .................................................................................................................................... 253 4.4.2 Darstellung von Bayer-Bäumen............................................................................................................. 254 4.4.3 Suchen eines Schlüssels ......................................................................................................................... 256 4.4.4 Einfügen................................................................................................................................................. 258 4.4.5 Löschen .................................................................................................................................................. 261 4.4.6 Demonstration eines 3ären bzw. 5ären Bayer-Baums ........................................................................... 268 4.4.6 Auf Platte/ Diskette gespeicherte Datensätze......................................................................................... 270 4.4.7 B*-Bäume .............................................................................................................................................. 272 4.5 Digitale Suchbäume .................................................................................................................................... 275 4.5.1 Grundlagen und Definitionen ................................................................................................................ 275 4.5.2 Tries ....................................................................................................................................................... 276 4.5.3 Binäre Tries............................................................................................................................................ 279 4.5.4 Patricia Bäume (Compressed Tries)....................................................................................................... 279 4.5.5 Suffix Tries ............................................................................................................................................ 281 4.5.6 Dateikompression mit dem Huffman-Algorithmus................................................................................ 281 5. GRAPHEN UND GRAPHENALGORITHMEN................................................................................ 282 5.1 Einführung .................................................................................................................................................. 282 5.1.1 Grundlagen............................................................................................................................................. 282 5.1.2 Definitionen ........................................................................................................................................... 286 5.1.3 Darstellung in Rechnerprogrammen ...................................................................................................... 291 5.2 Durchlaufen von Graphen ......................................................................................................................... 295 5.2.1 Tiefensuche (depth-first search)............................................................................................................. 295 5.2.2 Breitensuche (breadth-first search) ........................................................................................................ 299 5.2.3 Implementierung .................................................................................................................................... 302 5.3 Topologischer Sort ...................................................................................................................................... 306 5.4 Transitive Hülle........................................................................................................................................... 309 5 Algorithmen und Datenstrukturen 5.5 Kürzeste Wege............................................................................................................................................. 310 5.5.1 Der Algorithmus von Dijkstra................................................................................................................ 310 5.5.2 Der Algorithmus von Floyd ................................................................................................................... 312 5.6 Minimale Spannbäume............................................................................................................................... 313 5.6.1 Der Algorithmus von Prim..................................................................................................................... 313 5.6.2 Der Algorithmus von Kruskal................................................................................................................ 316 6 Algorithmen und Datenstrukturen Literaturverzeichnis Sauer, Jürgen: Programmieren in Java, Skriptum zur Vorlesung im WS 2005/2007 http://fbim.fh-regensburg.de/~saj39122/pgj/index.html Sauer, Jürgen: Programmieren in C++, Skriptum zur Vorlesung im SS 2006 http://fbim.fh-regensburg.de/~saj39122/pgc/index.html Sauer, Jürgen: Datenbanken, Skriptum zur Vorlesung im SS 2007 http://fbim.fh-regensburg.de/~saj39122/dbnew/index.html Sedgewick, Robert: Algorithmen in Java, 3.überarbeitete Auflage, Pearson Studium, München …. , 2003 Wirth, Nicklaus: Algorithmen und Datenstrukturen, 2. duchgesehene Auflage, Teubner, Stuttgart 1979 Ottmann, Thomas und Widmayer, Peter: Algorithmen und Datenstrukturen, BI Wissenschaftsverlag, Mannheim /Wien /Zürich 1990 Weiss, Marc Allen: Data Structures and Algorithm Analysis in Java, Pearson, Boston …., 2007 Nowak, Johannes: Fortgeschrittene Programmierung mit Java 5, dpunkt.verlag, Heidelberg 2005 Saake, Gunter und Sattler, Kai Uwe: Algorithmen und Datenstrukturen, dpunkt.verlag, 2. überarbeitete Auflage, Heidelberg, 2004 Maurer, H.: Datenstrukturen und Programmierverfahren, Teubner,Stuttgart 1974 Krüger, Guido und Stark, Thomas: Handbuch der Java-Programmierung, 5. Auflage, HTML-Ausgabe 5.0.1, Addison-Wesley, 2007 Ullenboom, Christian: Java ist auch eine Insel, 7. aktualisierte Auflage, HTMLVersion 7 Algorithmen und Datenstrukturen 8 Algorithmen und Datenstrukturen 1. Grunlegende Konzepte 1.1 Die zentralen Begriffe In den 50er Jahren bedeutete „Rechnen“ auf einem Computer weitgehend „numerisches Lösen“ wissenschaftlich-technischer Probleme. Kontroll- und Datenstrukturen waren sehr einfach und brauchten daher nicht weiter untersucht werden. Ein bedeutender Anstoß kam hier aus der kommerziellen Datenverarbeitung (DV). So führte hier bspw. die Frage des Zugriffs auf ein Element einer endlichen Menge zu einer großen Sammlung von Algorithmen 1, die grundlegende Aufgaben der DV lösen. Dabei ergab sich: Die Leistungsfähigkeit dieser Lösungen (Programme) ist wesentlich bestimmt durch geeignete Organisationsformen für die zu bearbeitenden Daten. Der Datentyp oder die Datenstruktur und die zugehörigen Algorithmen sind demnach ein entscheidender Bestandteil eines leistungsfähigen Programms. Datenstrukturen und Programmierverfahren bilden eine Einheit. Bei der Formulierung des Lösungswegs ist man auf eine bestimmte Darstellung der Daten festgelegt. Rein gefühlsmäßig könnte man sagen: Daten gehen den Algorithmen voraus. Programmieren führt direkt zum Denken in Datenstrukturen, um Datenelemente, die zueinander in Beziehung stehen, zusammen zu fassen. Mit Hilfe solcher Datenstrukturen ist es möglich, sich auf die relevanten Eigenschaften der Umwelt zu konzentrieren und eigene Modelle zu bilden. Die Leistung des Rechners wird dabei vom reinen Zahlenrechnen auf das weitaus höhere Niveau der „Verarbeitung von Daten“ angehoben Datenstrukturen und Algorithmen bilden die wesentlichen Bestandteile der Programmierung. Ein erster Versuch soll diese zentralen Begriffe so festlegen (bzw. abgrenzen): Datenstruktur Ein auf Daten anwendbares Ordnungsschema (z.B. ein Datensatz oder Array). Mit der Hilfe von Datenstrukturen lassen sich die Daten interpretieren und spezifische Operationen auf ihnen ausführen Algorithmus Verarbeitungsvorschrift, die angibt, wie Eingabe(daten) schrittweise mit Hilfe von Anweisungen auf Rechnern in Ausgabe(daten) umgewandelt werden. Für die Lösung eines Problems existieren meist mehrere Algorithmen, die sich in der Länge sowie der für die Ausführung benötigte Zeit unterscheiden. Programm und Programmiersprache Ein Programm ist die Formulierung eines Algorithmus und seiner Datenbereiche in einer Programmiersprache. Eine Programmiersprache erlaubt, Algorithmen präzise zu beschreiben. Insbesondere legen sie fest: - die elementaren Operationen - die Möglichkeiten zu ihrer Kombination 1 D. E. Knuth hat einen großen Teil dieses Wissens in "The Art of Computer Programming" zusammengefaßt 9 Algorithmen und Datenstrukturen - die zulässigen Datenbereiche 1.2 Algorithmische Grundkonzepte 1.2.1 Algorithmenbegriffe Algorithmen im Alltag Gegeben ist ein Problem. Eine Handlungsvorschrift, deren mechanisches Befolgen - ohne Verständnis des Problems - mit sinnvollen Eingabedaten - zur Lösung des Problems führt, wird Algorithmus genannt. Ein Problem, für dessen Lösung ein Algorithmus existiert, heißt berechenbar. Bsp.: - Zerlegung handwerklicher Arbeiten in einzelne Schritte - Kochrezepte - Verfahren zur schriftlichen Multiplikation - Algorithmen zur Bestimmung des größten gemeinsamen Teiles zweier natürlichen Zahlen - Bestimmung eines Schaltjahres - Spielregeln Der intuitive Algorithmenbegriff Ein Algorithmus ist eine präzise (d.h. in einer festgelegten Sprache abgefasste) endliche Beschreibung eines allgemeinen Verfahrens unter Angabe ausführbarer (Verarbeitungs-) Schritte. Ein Algorithmus (in der EDV) ist - ein Lösungsschritt für eine Problemklasse (konkretes Problem wird durch Eingabeparameter identifiziert) - geeignet für die Implementierung als Rechnerpogramm - endliche Folge von elementaren, ausführbaren Instruktionen Verarbeitungsschritten 1.2.2 Terminierung und Determinismus Abgeleitet vom intuitiven Algorithmenbegriff spielen bei der Konzeption von Algorithmen die Begriffe Terminierung, Determinismus und Vollständigkeit eine Rolle: Terminierung Ein Algorithmus heißt terminierend, wenn er (bei jeder erlaubten Eingabe von Parametern) nach endlich vielen Schritten abbricht. Determinismus 10 Algorithmen und Datenstrukturen Ein Algorithmus hat einen deterministischen Ablauf, wenn er eine eindeutige Schrittfolge besitzt. Der Algorithmus läuft bei jedem Ablauf mit den gleichen Eingaben durch dieselbe Berechnung. Ein Algorithmus liefert ein determiniertes Ergebnis, wenn bei vorgegebener Eingabe (auch bei mehrfacher Durchführung) stes ein eindeutiges Ergebnis erreicht wird. Nicht deterministische Algorithmen mit determiniertem Ergebnis heißen determinierter Algorithmus.Nicht deterministische Algorithmen können zu einem determiniertem Ergebnis führen, z.B.: 1. Nimm eine Zahl x ungleich Null 2. Entweder: Addiere das Dreifache von x zu x und teile das Ergebnis durch den Anfangswert von x Oder: Subtrahiere 4 von x und subtrahiere das Ergebnis von x 3. Schreibe das Ergebnis auf Vollständigkeit Alle Fälle, die bei korrekten Eingabedaten auftreten können, werden berücksichtigt. Bsp.: Nichtvollständige Algorithmen (1) Wähle zufällig eine Zahl x (2) Wähle zufällig eine Zahl y (3) Das Ergebnis ist x/y Was ist, wenn y == 0 sein sollte Nicht terminierender Algorithmus (1) Wähle zufällig eine Zahl x (2) Ist die Zahl gerade, wiederhole ab (1) (3) Ist die Zahl ungerade, wiederhole ab (1) Nicht determinierter Algorithmus 60 64 (1) Wähle zufällig eine natürliche Zahl zwischen 2 und 2 (2) Prüfe, ob die Zahl eine Primzahl ist. (3) Falls nicht, wiederhole ab 1. Das Ergenis ist immer eine Primzahl, aber nicht die gleiche, daher ist der Algorithmus nicht determiniert. Deterministische, terminierende Algorithmen definieren jeweils eine Ein/Ausgabefunktion: f : Eingabewerte -> Ausgabewerte Algorithmen geben eine konstruktiv ausführbare Beschreibung dieser Funktion, die Funktion heißt Bedeutung (Semantik) des Algorithmus. Es kann mehrere verschiedene Algorithmen mit der gleichen Bedeutung geben. 1.2.3 Algorithmenbausteine Gängige Bausteine zur Beschreibung bzw. Ausführung von Algorithmen sind: - elementare Operationen - sequentielle Ausführung (ein Prozessor) Der Sequenzoperator ist „;“. Sequenzen ohne Sequenzoperator sind häufig durchnummeriert und können schrittweise verfeinert werden, z.B: (1) Koche Wasser (2) Gib Kaffepulver in Tasse (3) Fülle Wasser in Tasse 11 Algorithmen und Datenstrukturen (2) kann verfeinert werden zu: Öffne Kaffeedose; Entnehme Löffel von Kaffee; Kippe Löffel in Tasse; Schließe Kaffeedose; - parallele Ausführung - bedingte Ausführung Die Auswahl / Selektion kann allgemein so formuliert werden: falls Bedingung, dann Schritt bzw. falls Bedingung dann Schritt a sonst Schritt b „falls ... dann ... sonst ...“ entspricht in Programmiersprachen den Konstrukten: if Bedingung then ... else … fi if Bedingung then … else …endif if (Bedingung) … else … - Schleife (Iteration) Dafür schreibt man allgemein wiederhole Schritte bis Abbruchkriterium Häufig findet man auch die Variante solange Bedingung führe aus Schritte bzw. die Iteration über festen Bereich wiederhole für Bereichsangabe Schleifenrumpf Diese Schleifenkonstrukte Konstrukten: wiederhole ... bis ... solange … führe aus wiederhole für entsprechen repeat ... until … do … while ... while … do ... while ( ... ) ... for each ... do … for ... do … for ( ... ) ... - Unterprogramm (Teilalgoritmus) - Rekursion 12 jeweils den Programmiersprachen- Algorithmen und Datenstrukturen Eine Funktion (mit oder ohne Rückgabewert, mit oder ohne Parameter) darf in der Deklaration ihres Rumpfes den eigenen Namen verwenden. Hierdurch kommt es zu einem rekursiven Aufruf. Typischerweise werden die aktuellen Parameter so modifiziert, daß die Problemgröße schrumpft, damit nach mehrmaligem Wiederholen dieses Prinzips keine weiterer Aufruf erforderlich ist und die Rekursion abbrechen kann. 1.2.4 Paradigmen der Algorithmenbeschreibung Ein Algorithmenparadigma legt Denkmuster fest, die einer Beschreibung eines Algorithmus zugrunde liegen. Faßt man einen Algorithmus als Beschreibung eines allgemeinen Verfahrens unter Verwendung ausführbarer elementarer Schritte auf, dann gibt es 2 grundlegende Arten, Schritte von Algorithmen zu notieren: - Applikative Algorithmen sind eine Verallgemeinerung der Funtionsauswertung mathematisch notierter Funktionen. In ihnen spielt die Rekursion 2 eine wesentliche Rolle. - Imperative Algorithmen basieren auf einem einfachen Maschinenmodell mit gespeicherten und änderbaren Werten. Hier werden primär Schleifen und Alternativen als Kontrollbausteine eingesetzt. In der Informatik sind darüber hinaus noch folgende Paradigmen wichtig: - Objektorientiete Algorithmen. In einem objektorientierten Algorithmus werden Datenstrukturen und Methoden zu einer Klasse zusammengefasst. Von jeder Klasse können Objekte gemäß der Datenstruktur erstellt und über die Methode manipuliert werden. Das objektorientierte Paradigma ist kein Algorithmenparadigma im engeren Sinne, da es sich um ein Paradigma zur Strukturierung von Algorithmen handelt, das sowohl mit applikativen, imperativen und logischen Konzepten zusammen eingesetzt werden kann. - logische (deduktive) Algorithmen. Ein logischer Algorithmus führt Berechnungen durch, indem er aus Fakten unjd Regeln durch Ableitungen in einem logischen Kalkül weitere Fakten ausweist. 2 vgl. 3.3 13 Algorithmen und Datenstrukturen 1.2.4.1 Applikative Algorithmen Idee: Defintion zusammengesetzter Funktionen durch Ausdrücke / Terme, z.B. f ( x) = 5 x + 1 . Definitionen Ein applikativer Algorithmus ist eine Liste von Funktionsdefinitionen f1 (v1,1 ,..., v1,n1 ) = t1 (v1,1 ,..., v1,n1 ) . . f m (v m1,1 ,..., v m1,nm ) = t m (v m1,1 ,..., v m ,nm ) v1 ,..., v n : Unbestimmte vom Typ τ 1 ,...,τ n , formale Parameter. t (v1 ,..., v n ) : ein Term (/Ausdruck), heißt Funktionsausdruck Die erste Funktion wird ausgewertet und bestimmt die Bedeutung (Semantik) des Algorithmus. Bsp.: Auswertungen 3 1. f ( x, y ) = if g ( x, y ) then h( x + y ) else h( x − y ) fi g ( x, y ) = ( x = y ) or odd ( y ) h( x) = j ( x + 1) ∗ j ( x − 1) j ( x) = 2 x − 3 4 f (1,2) a if g (1,2) then h(1 + 2) else h(1 − 2) fi a if 1 = 2 or odd (2) then h(1 + 2) else h(1 − 2) fi a if 1 = 2 or false then h(1 + 2) else h(1 − 2) fi a if false or false then h(1 + 2) else h(1 − 2) fi a if false then h(1 + 2) else h(1 − 2) fi a h(1 − 2) a h(−1) a j (−1 + 1) ∗ j (−1 − 1) a j (0) ∗ j (−1 − 1) a j (0) ∗ j (−1 − 1) a j (0) ∗ j (−2) a j (2 ∗ 0 − 3) ∗ j (−2) a (−3) ∗ (−7) a 21 2. f ( x, y ) = if x = 0 then y else ( if x > 0 then f ( x − 1, y ) + 1else − f (− x,− y ) fi ) fi f (0, y ) a y für alle y f (1, y ) a f (0, y ) + 1a y + 1 f (2, y ) a f (1, y ) + 1a y + 1 + 1 a y + 2 3 x, y : ganze Zahlen 4 a : konsekutive Ausführung mehrerer elementarer Termauswertungsgebiete 14 Algorithmen und Datenstrukturen …. f (n, y ) a y + n f (−1, y ) a − f (1,− y ) a −(1 − y ) a y − 1 … f ( x, y ) = x + y Eine Funktionsdefinition definiert eine Funktion f : τ 1 × τ 2 × ...τ n → τ n Sind a1 ,..., a n Werte vom Typ τ 1 ,...,τ n , so ersetzt man bei der Auswertung von f (a1 ,..., a n ) im definierten Vorkommen v1 durch a1 und wertet t (a1 ,..., a n ) aus. a1 ,..., a n : aktuelle Parameter f (a1 ,..., a n ) : Funktionsaufruf Aufrufe definierter Funktionen dürfen als Terme verwendet werden. Bsp. für applikative Algorithmen 1. Fakultätsberechnung x!= x ∗ ( x − 1) ∗ ( x − 2) ∗ ... ∗ 2 ∗ 1 für x > 0 mathematische Funktion fak ( x) = if x ≤ 0 then1else x ∗ fak ( x − 1) applikativer Algorithmus 5 2. Größter gemeinsamer Teiler (ggT) ggT ( x, x) = x mathematische ggT ( x, y ) = ggT ( y, x) Gesetzmäßigkeiten ggT ( x, y ) = ggT ( x, y − x) für x < y applikativer Algorithmus ggT ( x, y ) = if ( x ≤ 0) or ( y ≤ 0) then ggT ( x, y ) else if x = y then x else if x > y then ggT ( y, x) else ggT ( x, y − x) fi fi fi; ggT ist korrekt für positive Eingaben, bei negativen Eingaben ergeben sich nicht abbrechbare Berechnungen (undefinierte Funktionen) 6. ggT (39,15) a ggT (15,39) + ggT (15,24) a ggT (15,9) a ggT (9,15) a ggT (9,6) a ggT (6,9) ggT (6,3) a ggT (3,6) + ggT (3,3) a 3 3. Fibonacci-Zahlen: f 0 = f 1 = 1, f i = f i −1 + f i − 2 für i > 0 fib( x) = if ( x = 0) or ( x = 1) then1 else fib( x − 2) + fib( x − 1) fi ⎧ x _ te Fibonacci − Zahl falls x ≥ 0 Bedeutung: fib( x) = ⎨ sonst ⎩ 1 5 6 vgl. 1.2.5 Das Berechnungsschema stützt sich auf eine Formularisierung des Originalverfahrens von Euklid ab. 15 Algorithmen und Datenstrukturen 1.2.4.2 Imperative Algorithmen In einem imperativen Algorithmus gibt es Variable, die verschiedene Werte annehmen können. Die Menge aller Variablen und ihrer Werte (sowie der Programmzähler) beschreiben den Zustand zu einem bestimmten Zeitpunkt. Ein Algorithmus bewirkt eine Zustandstransformation. Imperative Konzepte - Anweisungen -- primitive Anweisungen: Zuweisung, Block, Prozeduraufruf -- zusammengesetzte Anweisungen: Sequenz, Auswahl, Iteration - Ausdrücke -- primitive Ausdrücke: Konstante, Variable, Funktionsaufruf -- zusammengesetzte Ausdrücke: Operanden / Operatoren - Datentypen -- primitive Datentypen: Wahrheitswerte, Zeichen, Zahlen, Aufzählung -- zusammengesetzte Datentypen: Felder, Verbund, Vereinigung, Zeiger - Abstraktion -- Anweisung -- Ausdruck: Funktionsdeklaration -- Datentyp: Typdeklaration - Weitere Konzepte -- Ein- und Ausgabe -- Ausnahmenbehandlung -- Bibliotheken -- Parallele und verteilte Berechnungen Wertzuweisungen sind die einzigen elementaren Anweisungen imperativer Algorithmen. Aus ihnen werden zusammengesetzte Anweisungen gebildet, aus denen imperative Algorithmen bestehen. Elementare Anweisungen können auf unterschiedliche Art zu komplexen Anweisungen zusammengestzt werden: (1) sequentielle Ausführung (2) bedingte Ausführung (3) wiederholte Ausführung (4) Ausführung als Unterprogramm (5) rekursive Ausführung eines Unterprogramms Diese Möglichkeiten werden als Kontrollstrukturen bezeichnet. 1.2.4.3 Objektorientierte Algorithmen Das objektorientierte Paradigma der Algorithmenentwicklung hat verschiedene Wurzeln: - Realisierung abstrakter Datentypen 7 Rechnergeeignete Modellierung der realen Welt (objektorientierte Analyse) Problemnaher Entwurf von Softwaresystemen (objektorientiertes Design) Problemnahe Implementierung (objektorientierte Programmierung Ein Objekt ist die Repräsentation eines Gegenstands und Sachverhalts der realen Welt oder eines gedanklichen Konzepts. 7 Vgl. 1.3.5.1 16 Algorithmen und Datenstrukturen Es ist gekennzeichnet durch - - eine eindeutige Identität, durch die es sich von anderen Objekten unterscheidet Wertbasierte Objektmodelle: In diesem Modell besitzen Objekte keine eigene Identität im eigentlichen Sinn. Zwei Objekte werden schon als identisch angesehen, wenn ihr Zustand gleich ist. Identitätsbasierte Objektmodelle: Jedem Objekt innerhalb des Systems wird eine vom Wert unabhängige Identität zugeordnet, statische Eigenschaften zur Darstellung des Zustands des Objekts in Form von Attributen dynamische Eigenschaften in Form von Methoden, die das Verhalten des Objekts beschreiben Der Zustand eines Objekts zu einem Zeitpunkt entspricht der Belegung der Attribute des Objekts zu diesem Zeitpunkt. Der Zustand kann mit Hilfe von Methoden erfragt und geändert werden. Methoden sind in der programmiesprachlichen Umsetzung Prozeduren und Funktionen, denen Parameter übergeben werden können. Der Zustand eines eine Methode ausführenden Objekts (und nur dieses Objekts) ist der Methode im Sinne einer Menge globaler Variablen direkt zugänglich. Es kann daher sowohl gelesen als auch geändert werden. Objekte verwenden das Geheimnisprinzip und das Prinzip der Kapselung. Sie verbergen ihre Interna: - Zustand (Belegung der Attribute) Implementierung ihres Zustands Implementierung ihres Verhaltens Objekte sind nur über ihre Schnittstelle, also über die Menge der vom Objekt der Außenwelt zur Verfügung gestellten Methoden zugänglich. Man spricht von den Diensten des Objekts. Objekte interagieren über Nachrichten: - Ein Objekt x sendet eine Nachricht an Objekt y. y empfängt die Nachricht von x Innerhalb der Programmiersprache wird dieser Vorgang meistens durch einen Methodenaufruf implementiert Nachrichten (Methodenaufrufe) können den Zustand eines Objekts verändern Ein Objekt kann sich selbst Nachrichten schicken. Objekte können in Beziehung zueinander stehen. - - - Die Beteiligten an eine Beziehung nehmen Rollen ein, z.B.: Rolle des Arztes: „behandelnder Arzt“, Rolle des Patienten: „Patient“ Ein Objekt kann mit mehreren Objekten in Beziehung stehen Rolle vom Arzt: „behandelnder Arzt“ Rolle von Patient 1: „Patient“, Rolle von Patient 2: „Patient“ Nachrichen können nur ausgetauscht werden, wenn eine Beziehung besteht Beziehungen können sich während der lebenszeit eines Objekts verändern Es gibt in der Regel Objekte, die sich bezüglich der Attribute, Methoden und Beziehungen ähnlich sind. Daher bieten es sich an, diese Objekt zu einer Klasse zusammenzufassen. Die Klasse beinhaltet dann auch Angaben darüber, wie Objekte dieser Klasse verwaltet (z.B. erzeugt oder gelöscht) werden können. - Klassendefinitionen sind eng verwandt mit abstrakten Datentypen. Sie legen Attribute und Methoden der zugehörigen Objekte fest Objekte dieser Klasse nennt man auch Instanzen dieser Klasse 17 Algorithmen und Datenstrukturen - Beziehungen (Assoziationen) zwischen Objekten werden auf Klassenebene beschrieben Ein Konstruktor ist eine Methode zur Erzeugung von Objekten 8. - Es gibt Attribute von Klassen, die nicht an konkrete Instanzen gebunden sind. Diese heißen Klassenvariable oder statische Vartiable. Klassenvariable existieren für die gesamte Lebensdauer einer Klasse genau einmal – unabhängig davon, wie viele Objekte erzeugt wurden Neben Klassenvariablen gibt es auch Klassenmethoden, d.h. Methoden, deren Existenz nicht an konkrete Objekte gebunden ist. Klassenmethoden werden auch statische Methoden genannt. Zu ähnlichen Klassen versucht man eine gemeinsame Oberklasse (Basisklasse) zu finden, die die Ähnlichkeiten aufnimmt. Unterklassen (Subklassen) werden nur um individuelle Eigenschaften ergänzt, denn eine Unterklasse erbt die Attribute und Methoden der Oberklasse. Eine Veraible vom Typ einer Basisklasse kann während ihrer Lebensdauer sowohl Objekte ihres eigenen Typs als auch soche von abgeleiteten Klassen aufnehmen. Dieses wird als Polymorphismus 9 bezeichner. - - - Eine Unterklasse erbt von ihrere Oberklasse alle Attribute und Methoden und kann diese um weitere Methoden ergänzen Erben heißt: Die Attribute und Methoden können in der Unterklasse verwendet werden, als wären sie in der Klasse selbst definiert. Vererbungen können mehrstufig sein. Es entstehen Vererbungshierarchien. Eine Unterklasse kann eine Variable deklarieren, die denselben Namen trägt, wie eine der Oberklasse. Hierdurch wird eine weiter oben liegende Variable verdeckt. Dies wird häufig dazu benutzt, um den Typ einert Variablen der Oberklasse zu überschreiben. In manchen Programmiersprachen gibt es Konstrukte, die den Zugriff auf verdeckte Variable ermöglichen Metoden, die aus der Basisklasse geerbt wurden, dürfen in der abgeleiteten Klasse überlagert, d.h. neu definiert werden. Da eine Variable einer Basisklasse Werte von verschiedenen Typen annehmen kann, entscheidet sichj bei überlagerten Mathoden erst zur Laufzeit, welche Methode zu verwenden ist: Dynamische Methodensuche Wird eine Methode in einer abgeleiteten Klasse überlagert, wird die ursprüngliche Methode verdeckt. Aufrufe der Methode beziehen sich auf die überlagerte Variante In amnchen Programmiersprachen gibt esw Konstrukte, die den Zugriff auf überlagerte Methoden ermöglichen 10. Mit Hilfe von Modifikatoren 11 können Sichtbarkeit und Eigenschaften von Klassen, Variablen und Methoden beeinflusst werden. - Die Sichbarkeit bestimmt, ob eine Klasse, Variable oder Methode in anderen Klassen genutzt werden kann. Eigenschaften, die über Modifikatoren gesteuert werden können, sind z.B. die Lebensdauer und die Veränderbarkeit Abstrakte Methoden: Eine Methode heißt abstrakt, wenn ihre Deklaration nur die Schnittstelle, nicht aber die Implementierung enthält. Im Gegensatz dazu stehen die konkreten Methoden, deren Deklaration auch Implementierungen besitzen 12. Abstrakte Methoden können nicht aufgerufen werden, sie definieren nur eine 8 Vgl. Skriptum zur Vorlesung im WS 2005 / 2006: Programmieren in Java, 1.4.1.1.3 Vgl. Skriptum zur Vorlesung im WS 2005 / 2006: Programmieren in Java, 1.4.1.8 10 in Java: Verwendung des Präfixes: super 11 Bsp. für Modifikatoren in Java sind: public, private, static, final, … 12 Java: Die Deklaration einer abstrakten Methode erfolgt durch den Modifikator abstract. 9 18 Algorithmen und Datenstrukturen Schnittstelle. Erst durch Überlagerung in einer abgeleiteten Klasse und durch Angabe der fehlenden Implementierung wird eine abstrakte Klasse konkret. Abstraklte Klassen: Eine Klasse, die nicht instanziiert werden kann, heißt abstrakte Klasse. Klassen, von denen Objekte erzeugt werden können, sind konkrete Klassen. Jede Klasse, die mindestens eine abstrakte Methode besitzt, ist abstrakt 13. Schnittstellen: Eine Schnittstelle (interface) ist in Java eine Klasse, die ausschließlich Konstanten und abstrakte Methoden enthält. Zur Definition einer Schnittstelle wird das Schlüsselwort class durch das Schlüsselwort interface ersetzt. Generizität: Unter Generizität versteht man die Parametrisierung von Klassen, Datentypen, Prozeduren, Moduln, Funktionen, etc. Als Parameter werden in der Regeln Datentypen (manchmal auch Algorithmen in Form von Prozeduren) verwendet. 1.2.4.4 Paradigmen und Programmiersprachen Zu den Paradigmen korrespondieren jeweils Programmiersprachen, die diesen Ansatz realisieren. Moderne Programmiersprachen vereinen oft Ansätze mehrerer Paradigmen. So ist bspw. Java objektorientiert 14, umfasst aber auch imperative und applikative Elemente. 1.2.5 Beschreibung von Algorithmen Verbreitetes Grundschema von Algorithmen Name des Algorithmus und Parameterliste Spezifikation des Ein- und Ausgabeverhaltes 1. Schritt Einführung von Hilfsgrößen Vorbereitung Initialisierungen 2. Schritt Prüfe, ob ein einfacher Fall vorliegt Trivialfall Falls ja: Ergebnis ausgeben und enden 3. Schritt Reduziere Problemstellung A auf einfachere Form B Problemreduktion, (z.B. Aufteilen in Teilprobleme) Ergebnisaufbau 4. Schritt entweder Rekursion: oder Iteration: Rekursion bzw. Rufe Algorithmus mit Fahre mit B anstelle a bei Iteration reduziertem B auf Schritt 2 fort Verbale Umschreibung von Algorithmen Eine derartige Handlungsanweisung könnte bspw. die „Berechnung des größten gemeinsamen Teilers von a und b“ in folgender Weise sein: 1. Weise x den Wert von a zu 2. Weise y den Wert von b zu 3. Falls x gleich y ist: gehe zu 9 13 Java: Es ist erforderlich, abstrakte Klassen abzuleiten und in der abgeleiteten Klasse eine oder mehrere abstrakte Methoden zu implementieren. Die Konkretisierung kann über mehrere Stufen erfolgen. 14 Vgl. Skriptum zur Vorlesung im WS 2005 / 2006: Programmieren in Java, 1. 19 Algorithmen und Datenstrukturen 4. Falls x kleiner als y ist: gehe zu 7 5. Weise x den Wert von (x-y) zu 6. Gehe zu 3 7. Weise y den Wert von (y-x) zu 8. gehe zu 3 9. Weise ggTden Wert von x zu Pseudo-Code - Abstrakte Beschreibung eines Algorithmus - Strukturierter als Beschreibung mit normalen Sprachvokabular - weniger detailliert als ein Programm - Bevorzugete Notation zur Beschreibung eines Algorithmus - versteckt Programmimplementierungsprobleme Bsp.: Finden des größten Elements in einem Array Algorithmus arrayMax(a,n) Input array a mit n Ganzzahlen Output größtes Element von a currentMax = a[0] for i= 1 to n-1 do if (a[i] > curentMax then currentMax = a[i] return currentMax Pseudocode-Details: - Kontrollfluss -- if … then … [else …] -- while … do … -- repeat … until … -- for … do - Einrücken ersetzt Klammern - Deklaration von Methoden Algorithmus methode(arg [,arg …]) Input … Output … - Rückgabewert return Ausdruck - Ausdrücke = Zuweisung == Gleiheitstest 2 Subscripts und andere mathematische Formulierungen sind erlaubt n Pseudo-Code Elemente: Sequenz Verzeigung { Anweisung_1 Anweisung_2 … Anweisung_n } if Bedingung { Anweisung_1 Anweisung_2 … Anweissung_n } else { Anweisung_m … Anweisung_k } 20 Algorithmen und Datenstrukturen Iteration While Bedingung { Anweisung_1 Anweisung_2 … Anweisung_n } Graphische Darstellung von Flußdiagrammen Normierte Methode (DIN 66001) zur Darstellung von Programmen Kontrollstrukturen und Struktogramme Strukturblock Anweisung_1 Anweisung_2 …. Java-Struktur 15 Kommentar Block in geschweiften Klammern { Anweisung_1; Anweisung_2; ….. Eine Folge von Anweisungen, die alle der Reihe nach abgearbeitet werden, bezeichnet man als Sequenz. Anweisung_n; } Anweisung_n Sequenz if-Anweisung if (Bedingung) { anweisung1; } else { Anweisung2; } Fallunterscheidung (bedingte Anweisung) 1 2 3 A1 A2 A3 Fall …. Mehrfachauswahl sonst An Mit einer Anweisung der Form Wenn Bedingung erfüllt dann führe Anweisung1 aus sonst führe Anweisung 2 aus führt man eine Fallunterscheidung durch switch-Anweisung Mehrfachauswahl switch (Ausdruck) { case Wert1 : Anweisung1; break; case Wert2 : Anweisung2; break; default: Anweisungn } Der Ausdruck muß ganzzahlig sein. Das Programm wird an der case-Anweisung fortgesetzt., deren Wert dem Ausdruck entspricht. Falls Ausdruck keinem der Werte entspricht, geht es mit der default-Anweisung weiter for-Schleife Eine Anweisung der Form for (int i=1;i <=n; i++) { Für Zähler = Anfang bis Ende Anweisung für i=1 bis n Anweisung 15 Vgl. Skriptum zur Vorlesung im WS 2005 / 2006: Programmieren in Java, 2.4 21 Algorithmen und Datenstrukturen Gezählte Schleife for-Schleife Anweisung; } heißt gezählte Schleife. Gezählte Schleifen werden dann benutzt, wenn man weiß, wie oft eine Schleife durchlaufen werden muß while-Schleife Eine Anweisung der Form while (Bedingung) { Anweisung; } Solange bedingung erfüllt führe Anweisung aus do-while-(repeat)Schleife Eine Anweisung der Form solange Bedingung Anweisung while-Schleife Anweisung bis Bedingung repeat-Schleife do { Anweisung; } while (Bedingung); Prozeduraufruf Prozedurname(Arg1, Arg2, … , Argn); heißt Schleife mit Eingangsbedingung. Trifft die Bedingung anfangs nicht zu, so wird die Wiederholungsanweisung nicht ausgeführt Wiedrhole Anweisung Solange Bedingung erfüllt heißt Schleife mit Ausgangsbedingung. Im Unterschied zur while-Schleife wird die zu wiederholende Anweisung mindestens einmal ausgeführt. Prozeduren werden über ihren Namen aufgerufen. In Klammern kann man Argumente übergeben. Prozeduraufruf 1.2.6 Formale Eigenschaften von Algorithmen 1.2.6.1 Korrektheit und Terminierung Die wichtigste formale Eigenschaft eines Algorithmus ist die Korrektheit. Dazu muß gezeigt werden, daß der Algorithmus die jeweils gestellte Aufgabe richtig löst. Man kann die Korrektheit eines Algorithmus im Allg. nicht durch Testen an ausgewählten Beispielen nachweisen 16: Durch Testen kann lediglich nachgewiesen werden, dass sich ein Programm für endlich viele Eingaben korrekt verhält. Durch eine Verifikation kann nachgewiesen werden, dass sich das Programm für alle Eingaben korrekt verhält. Bei der Zusicherungsmethode sind zwischen den Statements sogenannte Zusicherungen eingesetzt, die eine Aussage darstellen über die momentane Beziehung zwischen den Variablen. Typischerweise gibt man Zusicherungen als Kommentare vor. /* P */ 16 E. Dijkstra formulierte das so: Man kann durch Testen die Anwesenheit von Fehlern, aber nicht die Abwesenheit von Fehlern nachweisen. 22 Algorithmen und Datenstrukturen while (b) { /* P && b */ … /* P */ } /* P && !b */ Zusicherungen enthalten boolsche Ausdrücke, von denen der Programmierer annimmt, dass sie an entsprechender Stelle gelten. Beginnend mit der ersten, offensichtlich richtigen Zusicherung lässt sich als letzte Zusicherung eine Aussage über das berechnete Ergebnis durch Anwendung der Korrektheitsformel 17 ableiten: { P } A { Q } - P und Q sind Zusicherungen P ist die pre-condition (Vorbedingung), beschreibt die Bedingungen (constraints). Q ist die post-condition (Nachbedingung), beschreibt den Zustand nach Ausführung der Methode Die Korrektheitsformel bedeutet: Jede Ausführung von A, bei der zu Beginn P erfüllt ist, terminiert in einem Zustand, in dem Q erfüllt ist. Die Korrektheitsformel bestimmt partielle Korrektheit : "Wenn P beim Start von A erfüllt ist, und A terminiert, dann wird am Ende Q gelten". Für die Terminierung gilt folgende Formel: { P} A. Sie bedeutet: "Wenn P beim Start von A erfüllt ist, wird A terminieren. Partielle Korrektheit und Terminierung führen zur totale Korrektheit. Totale Korrektheit ist eine stärkere Anforderung an das Programm. Da das Halteproblem bekanntlich unentscheidbar ist, kann im allgemeinen die totale Korrektheit nicht entschieden werden. 1.2.6.2 Effizienz Die zweite wichtige Eigenschaft eines Algorithmus ist seine Effizienz. Die wichtigsten Maße für die Effizienz sind der zur Ausführung des Algorithmus benötigte Speicherplatz und die benötigte Rechenzeit (Laufzeit): 1. Man kann die Laufzeit durch Implementierung des Algorithmus in einer Programmiersprache (z.B. C++) auf einem konkreten Rechner für eine Menge repräsentativer Eingaben messen. Bsp.: Implementierung eines einfachen Sortieralgorithmus in C++ mit Messen der CPU-Zeit 18. #include <time.h> // … clock_t start, finish; start = clock(); sort(…); 17 Robert Floyd hatte 1967 die Idee den Kanten von Flussdiagrammen Prädikate zuzuordnen, um Korrektheitsbeweise zu führen. C.A.R. Hoare entwickelte die Idee weiter, indem er Programme mit "Zusicherungen" anreicherte. Er entwickelte das nach ihm benannte "Hoare Tripel" 18 In Java steht zur Zeitmessung die Methode Methode currentTimeMillis() aus System zur Verfügung. currentTimeMillis bestimmt die Anzahl der Millisekunden, die seit Mitternacht des 1.1.1970 vergangen sind. 23 Algorithmen und Datenstrukturen finish = clock(); cout << "sort hat " << double (finish – start) / CLOCKS_PER_SEC << " Sek. benoetigt\n"; // … Solche experimentell ermittelten Meßergebnisse lassen sich nicht oder nur schwer auf andere Implementierungen und andere Rechner übertragen. 2. Aus dieser Schwierigkeit bieten sich 2 Auswege an: 1. Man benutzt einen idealiserenden Modellrechner als Referenzmaschine und mißt die auf diesem Rechner zur Ausführung des Algorithmus benötigte Zeit und benötigten Speicherplatz. Ein in der Literatur 19 zu diesem Zweck häufig benutztes Maschinenmodell ist das der RAM (Random-AccessMaschine). Eine solche Maschine verfügt über einige Register und eine (abzählbar unendliche) Menge einzeln addressierbarer Speicherzellen. Register und Speicherzellen können je eine (im Prinzip) unbeschränkt große (ganze oder reelle) Zahl aufnehmen. Das Befehlsrepertoire für eine RAM ähnelt einer einfachen, herkömmlichen Assemblersprache. Die Kostenmaße Speicherplatz und Laufzeit enthalten dann folgende Bedeutung: Der von einem Algorithmus benötigte Speicherplatz ist die Anzahl der zur Ausführung benötigten RAM-Speicherzellen. Die benötigte Zeit ist die Zahl der ausgeführten RAM-Befehle. 2. Bestimmung einiger für die Effizienz des Algorithmus besonders charakteristischer Parameter 20. Laufzeit und Speicherbedarf eines Algorithmus hängen in der Regel von der Größe der Eingabe ab 21. Man unterscheidet zwischen dem Verhalten im besten Fall, dem Verhalten im Mittel (average case) und dem Verhalten im schlechtesten Fall (worst case). In den meisten Fällen führt man eine worstcase Analyse für die Ausführung eines Algorithmus der Problengröße N durch. Dabei kommt es auf den Speicherplatz nicht an, lediglich die Größenordnung der Laufzeit- und Speicherplatzfunktionen in Abhängigkeit von der Größe der Eingabe N wird bestimmt. Zum Ausdruch dieser Größenordnung hat sich eine besondere Notation eingebürgert: die O-Notation bzw. Big-O-Notation. Laufzeit T(N): Die Laufzeit gibt exakt an, wieviel Schritte ein Algorithmus bei einer Eingabelänge N benötigt. T(N) kann man im Rahmen sog. assymptotischer Kostenmaße abschätzen. Für diese Abschätzung existieren die sog. Big-O-Notation (bzw. Ω - und Θ -Notation): Big-O-Notation: Ein Funktion f (N ) heißt von der Ordnung O ( g ( N )) , wenn 2 Konstante c0 und n0 existieren, so dass f ( N ) ≤ c o ⋅ g ( N ) für alle N > n0 . Die Big-O-Notation liefert eine Obergrenze für die Wachstumsrate von Funktionen: f ∈ O (g ) , wenn f höchstens so schnell wie g wächst. Man sagt dann: die Laufzeit eines Algorithmus "T(N) ist O(N)" oder "T(N) ist ein O(N)". Big- Ω -Notation: Ein Funktion f (N ) heißt von der Ordnung Ω( g ( N )) , wenn 2 Konstante c0 und n0 existieren, so dass f ( N ) ≥ c o ⋅ g ( N ) für alle N > n0 . Die Big- Ω -Notation liefert eine Untergrenze für die Wachstumsrate von Funktionen: f ∈ Ω(g ) , wenn f mindestens so schnell wie g wächst. θ -Notation: Das Laufzeitverhalten eines Algorithmus ist θ (N ) , falls O( N ) = Ω( N ) . Über θ (N ) kann das Laufzeitverhalten exakt beschrieben werden. 19 Vgl. Aho, Hopcroft, Ullman: The Design and Analysis of Computer Algorithms, Addison-Wesley Publishing Company 20 So ist es bspw. üblich, die Laufzeit eines Verfahrens zum Sortieren einer Folge von Schlüsseln durch die Anzahl der dabei ausgeführten Vergleichsoperationen zwischen Schlüsseln und die Anzahl der ausgeführten Bewegungen von den jeweiligen betroffenen Datensätzen zu messen. 21 die im Einheitskostenmaß oder im logarithmischen Kostenmaß gemessen wird 24 Algorithmen und Datenstrukturen T (N ) 22 aus dem Bereich der positiven reellen Zahlen: Ein Algorithmus hat die Komplexität O (g ) , wenn T ( N ) ∈ O ( g ) Damit lässt sich der Zeitbedarf eines Algorithmus darstellen als eine Zeitfunktion gilt. Meistens erfolgt die Abschätzung hinsichtlich der oberen Schranken (Worst Case): Groß-O-Notation. T (N ) c1 g (n) f ∈ Θ(g ) c 2 g ( n) n0 N Abb. 1.2-71: Assymptotische Kostenmaße Zeitbedarf eines Algorithmus: Ist N die Problemgröße, A ein Algorithmus, dann hat ein Algorithmus die Komplexität O(g ) , wenn für den Zeitbedarf von A T A (n) ∈ O( g ) gilt. Wenn nicht explizit anders beschrieben, ist T A (n) maximale Laufzeit für die gegebene Faustregel in der O-Notation Rechenregeln zur O-Notation. ⎧O( f ), falls g ∈ O( f ) Addition: f + g ∈ O(max( f , g )) = ⎨ ⎩O( g ), falls f ∈ O( g ) Die Additionsregel dient zur Bestimmung der Komplexität bei Hintereinanderausführung der Programme Multiplikation: f ⋅ g ∈ O( f ⋅ g ) Die Multiplikationsregel dient zur Bestimmung der Komplexität von ineinandergeschachtelten Schleifen Linearität: f (n) = a ⋅ g (n) + b ∧ Ω(1) ⇒ f ∈ O( g ) 1.2.7 Komplexität Für die algorithmische Lösung eines gegebenen Problems ist es unerläßlich, daß der gefundene Algorithmus das Problem korrekt löst. Darüber hinaus ist es natürlich wünschenswert, daß er dies mit möglichst geringem Aufwand tut. Die Theorie der 22 falls nicht explizit anders beschrieben, ist T (N ) die maximale Laufzeit für die gegebene Problemgröße N 25 Algorithmen und Datenstrukturen Komplexität von Algorithmen beschäftigt sich damit, gegebene Algorithmen hinsichtlich ihres Aufwands abzuschätzen und – darüber hinaus – für gegebene Problemklassen anzugeben, mit welchem Mindestaufwand Probleme dieser Klasse gelöst werden können. Meistens geht es bei der Ananlyse der Komplexität von Algorithmen (bzw. Problemklassen) darum, als Maß für den Aufwand eine Funktion anzugeben, wobei f ( Ν) = a bedeutet: „ Bei einem Problem der Größe N ist der Aufwand a“. Die Problemgröße „N“ bezeichnet dabei in der Regel ein grobes Maß für den Umfang einer Eingabe, z.B. die Anzahl der Elemente in der Eingabeliste oder die Größe eines bestimmten Eingabewertes. Der Aufwand „a“ ist in der Regel ein grobes Maß für die Rechenzeit. Die Rechenzeit wird häufig dadurch abgeschätzt, daß man zählt, wie häufig eine bestimmte Operation ausgeführt wird, z.B. Speicherzugriffe, Multiplikationen, Additionen, Vergleiche, etc. Bsp.: Wie oft wird die Wertzuweisung „x = x + 1“ in folgenden Anweisungen ausgeführt? 1. x = x + 1; ............ ..1-mal 2. for (i=1; i <= n; i++) x = x + 1;.. ..n-mal 3. for (i=1; i <= n; i++) for (j = 1; j <= n; j++) x = x + 1;................................... ......... n2-mal Die Aufwandfunktion läßt sich in den wenigsten Fällen exakt bestimmen. Vorherrschende Analysemethoden sind: - Abschätzungen des Aufwands im schlechtesten Fall - Abschätzungen des Aufwands im Mittel Selbst hierfür lassen sich im Allg. keine exakten Angaben machen. Man beschränkt sich dann auf „ungefähres Rechnen in Größenordnungen“. Bsp.: Gegeben: n ≥ 0 a1 , a 2 , a3 ,..., a n ∈ Z Gesucht: Der Index i der (ersten) größten Zahl unter den ai (i=1,...,n) Lösung: max = 1; for (i=2;i<=n;i++) if (amax < ai) max = i Wie oft wird die Anweisung „max = i“ im Mittel ausgeführt (abhängig von n)? Die gesuchte mittlere Anzahl sei Tn. Offenbar gilt: 1 ≤ Tn ≤ n . „max = i“ wird genau dann ausgeführt, wenn ai das größte der Elemente a1 , a 2 , a3 ,..., ai ist. Angenommen wird Gleichverteilung: Für jedes i = 1, ... , n hat jedes der Elemente a1 , a 2 , a3 ,..., a n die gleiche Chance das größte zu sein, d.h.: Bei N Durchläufen wird N/n-mal die Anweisung „max = i“ ausgeführt. Daraus folgt für N ⋅ Tn (Aufwendungen bei N Durchläufen vom „max = i“): N ⋅ Tn = N + N N N 1 1 1 + + ... + = N (1 + + + ... + ) 2 3 n 2 3 n Dies ist Hn, die n-te harmonische Zahl. Für Hn ist keine geschlossene Formel bekannt, jedoch eine ungefähre Abschätzung: Tn = H n ≈ ln n + γ 23. Interessant ist nur, daß Tn logarithmisch von n abhängt. Man schreibt Tn ist „von der Ordnung logn“, die multiplikative und additive Konstante sowie die Basis des Logarithmus bleiben unspezifiziert. 23 Eulersche Konstante γ = 0.57721566 26 Algorithmen und Datenstrukturen Diese sog. (Landau'sche) Big-O-Notation läßt sich mathematisch exakt definieren: f ( n) f (n) = O( g (n)) :⇔ ∃c, n0 ∀n ≥ n0 : f (n) ≤ c ⋅ g (n) , d.h. ist für genügend große n g ( n) durch eine Konstante c beschränkt. „f“ wächst nicht stärker als „g“. Diese Begriffsbildung wendet man bei der Analyse von Algorithmen an, um Aufwandsfunktionen durch Eingabe einer einfachen Vergleichsfunktion abzuschätzen, so daß f (n) = O( g (n)) gilt, also das Wachstum von f durch das von g beschränkt ist. Gebräuchliche Vergleichsfunktionen sind: O-Notation O(1) Aufwand Konstanter Aufwand O(log n) Logarithmischer Aufwand O(n) Linearer Aufwand Problemklasse Einige Suchverfahren für Tabellen („Hashing“) Allgemeine Suchverfahren für Tabellen (Binäre Suche) Sequentielle Suche, Suche in Texten, syntaktische Analyse in Programmen „schlaues Sortieren“, z.B. Quicksort O(n ⋅ log n) O(n 2 ) Quadratischer Aufwand Einige dynamische Optimierungsverfahren, z.B. optimale Suchbäume); „dummes Sortieren“, z.B. Bubble-Sort Multiplikationen Matrix mal Vektor Exponentieller Aufwand Viele Optimierungsprobleme, automatisches Beweisen (im Prädikatenkalkül 1. Stufe) Alle Permutationen O(n k ) für k ≥ 0 O(2 n ) O(n!) Zur Veranschaulichung des Wachstums konnen die folgende Tabellen betrachtet werden: f(N) ldN N N ⋅ ldN N2 N3 2N N=2 1 2 2 4 8 4 24=16 4 16 64 256 4096 65536 25=256 8 256 1808 65536 16777200 ≈ 1077 210 10 1024 10240 1048576 ≈ 109 ≈ 10308 220 20 1048576 20971520 ≈ 1012 ≈ 1018 ≈ 10315653 Unter der Annahme „1 Schritt dauert 1 μs = 10 −6 s folgt für N= N N2 N3 2N 3N N! 10 10 μs 100 μs 1 ms 1 ms 59 ms 3,62 s 20 20 μs 400 μs 8 ms 1s 58 min 771 Jahre 30 30 μs 900 μs 27 ms 18 min 6.5 Jahre 1016 Jahre Abb. 1.2-2: Polynomial- und Exponentialzeit 27 40 40 μs 1.6 ms 64 ms 13 Tage 3855 Jahre 1032 Jahre 50 50 μs 2.5 ms 125 ms 36 Jahre 108 Jahre 1049 Jahre 60 60 μs 3.6 ms 216 ms 366 Jahre 1013 Jahre 1066 Jahre Algorithmen und Datenstrukturen 1.2.7.1 Laufzeitberechnungen („Big-O“-) N Ein einfaches Beispiel: Gegeben ist die folgende Funktion zur Berechnung von ∑i 3 i =1 public static int sum(int n) { /* 1 */ int teilSumme; /* 2 */ teilSumme = 0; /* 3 */ for (int i = 1; i <= n; i++) /* 4 */ teilSumme += i * i * i; /* 5 */ returm teilSumme; } Analyse zur Effizienz: Zeile 1 und Zeile 2 zählen je einmal. Zeile 4 zählt viermal (2 Multiplikationen, Zuweisung und 1. Additition) und wird N-mal ausgeführt. Das ergibt 4N. Zeile 3 zeigt die Deklaration und Initialisierung von i (zählt zweimal), den Test i <= N und das Inkrementieren i++ (zählt jeweils N-mal). Insgesamt führt das zu 2N + 2. Ignoriert man Aufruf und Rückkehranweisung der Funktion erhält man 6N + 4. Man sagt dazu: Die Funktion besitzt ein Leistungsverhalten von O(N). Einiges kann bei der Abschätzung offensichtlich beschleunigt werden. In Zeile 3 steht bspw. eine O(1)-Anweisung. Es ist egal (für die Abschätzung der Laufzeitberechnung), ob bei der Ausführung diese Anweisung 2fach oder 3fach gezählt wird. Auch bzgl. der Schleife ist der Faktor 2 und die Addition von 2 unerheblich. Das führt zu folgenden Regeln zur Abschätzung des Leistungsverhaltens nach der „Big-O“-Notation: 1. Regel (für Schleifen): Die Laufzeit einer Schleife ist im wesentlichen bestimmt durch die Anzahl der Anweisungen innerhalb des Schleifenkörpers multipliziert mit der Anzahl der Iterationen. 2. Regel (für verschachtelte Schleifen): Die Laufzeit einer Anweisung innerhalb einer Gruppe verschachtelter Schleifen ist bestimmt durch die Laufzeit der Anweisung multipliziert mit dem Produkt aller Schleifengrößen. Bsp.: for (i=1; i <= n; i++) for (j = 1; j <= n; j++) k++; ist einzuordnen unter O(N2). 3. Regel (aufeinanderfolgende Anweisungen): Der größte Wert zählt für das Leistungsverhalten. Bsp.: for (int i=1; i <= n; i++) a[i] = 0; // O(N) for (int i=1; i <= n; i++) for (int j=1; j <= n; j++) a[i] += i + j; // O(N2) Insgesamt ergibt sich das Leistungsverhalten O(N2). 4. Regel: Die Laufzeit einer „if“-Anweisung ist niemals größer als die Laufzeit des Tests plus der größeren Laufzeit vom „ja“- bzw. „nein“-Zweig. 28 Algorithmen und Datenstrukturen Rekursionen können häufig auf einfache Schleifen mit dem Leistungsverhalten O(N) zurückgeführt werden, z.B.: public static long fakultaet(int n) { if (n <= 1) return 1; else return n * fakultaet(n-1); Liegen in einer Funktion mehrere rekursive Aufrufe vor, dann ist die Umsetzung in eine einfache Schleifenstruktur nicht so einfach. Bsp.: public static long fib(int n) { /* 1 */ if (n <= 1) /* 2 */ return 1; else /* 3 */ returm fib(n-1) + fib(n-2); } Die Analyse ergibt unter der Annahme, daß T(N) die Laufzeit nach einem Aufruf von fib(n) ist: Für N = 0, N = 1 ist T(0) = T(1) = 1 (irgendein konstanter Wert. In Zeile 3 wird fib(N-1) aufgerufen, was eine Laufzeit von T(N-1) bewirkt. Anschließend wird fib(N-2) aufgerufen, was eine Laufzeit von T(N-2) bewirkt. Zusammengezählt ergibt das: T(N) = T(N-1) + T(N-2) + 2. Da fib(N) = fib(N-1) + fib(N-2) ist, kann leicht gezeigt werden, daß T(N) >= fib(N) ist. 5 Man kann zeigen: fib( N ) < ( ) N . Das bedeutet: Die Laufzeit dieses Programms 3 wächst exponentiell (schlechter geht es nicht mehr). Man kann häufig dasselbe Problem mit verschieden Algorithmen lösen. Das Ziel ist natürlich, den für das Problem besten Algorithmus zu finden bzw. zu implementieren: Bsp.: Das Maximum-Subarray-Problem Gegeben ist eine Folge X von N ganzen Zahlen in einem Array. Gesucht ist die maximale Summe aller zusammenhängenden Teilfolgen. Sie wird als maximale Teilsumme bezeichnet. So ist für die Eingabefolge X[0] 31 X[1] -41 X[2] 59 X[3] 26 X[4] -53 X[5] 58 X[6] 97 X[7] -93 X[8] -23 X[9] 84 die Summe der Teilfolgen X[2] + X[3] + X[4] + X[5] + X[6] mit dem Wert (59 + 26 – 53 + 58 + 97) = 187 die Lösung des Problems. Lösungen zu diesem Problem können auf verschiedene Weise erreicht werden: 1. Lösung public { /* 1 /* 2 /* 3 /* /* /* /* /* 4 5 6 7 8 /* 9 static int maxSubsum1(int a[]) */ int maxSumme = 0; */ for (int i = 0; i < a.length;i++) */ for (int j = i; j < a.length; j++) { */ int summe = 0; */ for (int k = i; k <= j; k++) */ summe += a[k]; */ if (summe > maxSumme) */ maxSumme = summe; } */ return maxSumme; 29 Algorithmen und Datenstrukturen } N Die Analyse des Leistungsverhaltens wird bestimmt durch N j ∑∑∑1 = O( N 3 ) . Diese Summe i =1 j =i k =i berechnet, wieviele Male Zeile 6 ausgeführt wird. 2. Lösung public static int maxSubsum2(int a[]) { /* 1 */ int maxSumme = 0; /* 2 */ for (int i = 0; i < a.length;i++) { /* 3 */ int summe = 0; /* 4 */ for (int j = i; j < a.length; j++) { /* 5 */ summe += a[j]; /* 6 */ if (summe > maxSumme) /* 7 */ maxSumme = summe; } } /* 8 */ return maxSumme; } 2 In dieser Lösung ist das Leistungsverhalten auf O(N ) reduziert. 3. Lösung Diese Lösung folgt der „Divide-and-Conquer“-Strategie, die ein sehr allgemeines und mächtiges Prinzip zur algorithmischen Lösung von Problemen darstellt. Das zugehörige Problemlösungsschema kann allg. so formuliert werden: 1. Divide: Teile das Problem der Größe N in (wenigstens) 2 annähernd gleich große Teilprobleme, wenn N > 1 ist, sonst löse das Problem der Größe 1 direkt. 2. Conquer: Löse die Teilprobleme auf dieselbe Art. 3. Merge: Füge die Teillösungen zur Gesamtlösung zusammen. Abb.: Divide and Conquer-Verfahren zur Lösung eines Problems der Größe N Bei der Anwendung dieses Algorithmus auf das vorliegende Problem bewirkt das Teilen der Folge in Teilfolgen evtl. das Trennen der Teilfolge mit der größten Teilsumme, z.B.: Bei der Vorgabe a[0] 4 a[1] -3 a[2] 5 1. Häfte a[3] -2 a[4] -1 a[5] 2 a[6] 6 2. Hälfte a[7] -2 ist die größte Teilsumme in der ersten Teilhälfte 6 (a[0] + a[1] + a[2]), die größte Teilsumme in der zweiten Teilhälfte ist 8 (a[5] + a[6]). Die maximale Summe in der 1. Hälfte, die das letzte Element in der 1. Hälfte mit einschließt (a[0] + a[1] + a[2] + a[3]) ist 4. Die maximale Summe in der 2. Hälfte, die das erste Element in der 2. Hälfte einschließt ist 7. Die maximale Summe, die beide Hälften überspannt ist 4 + 7 = 11. Der Algorithmus muß demnach Teilsummenbildungen über die jeweilige Teilhälften berücksichtigen. private static int maxSubsum(int { /* 1 */ if (links == rechts) /* 2 */ if (a[links] > 0) /* 3 */ return a[links]; /* 4 */ else return 0; /* 5 */ int mitte = (links + /* 6 */ int maxLinkeSumme = /* 7 */ int maxRechteSumme = a[], int links, int rechts) // Falls dieses Element positiv ist // dann ist es die max.Teilsumme rechts) / 2; maxSubsum(a, links, mitte); maxSubsum(a, mitte + 1, rechts); 30 Algorithmen und Datenstrukturen /* 8 */ int maxLinkeGrenzSumme /* 9 */ for (int i = mitte; i >= links; i--) { linkeGrenzsumme += a[i]; if (linkeGrenzsumme > maxLinkeGrenzSumme) maxLinkeGrenzSumme = linkeGrenzsumme; } int maxRechteGrenzSumme = 0, rechteGrenzsumme = 0; for (int i = mitte + 1; i <= rechts; i++) { rechteGrenzsumme += a[i]; if (rechteGrenzsumme > maxRechteGrenzSumme) maxRechteGrenzSumme = rechteGrenzsumme; } if (maxLinkeSumme > maxRechteSumme) if (maxLinkeSumme > (maxRechteGrenzSumme + maxLinkeGrenzSumme)) return maxLinkeSumme; else return (maxRechteGrenzSumme + maxLinkeGrenzSumme); else if (maxRechteSumme > (maxRechteGrenzSumme + maxLinkeGrenzSumme) ) return maxRechteSumme; else return (maxRechteGrenzSumme + maxLinkeGrenzSumme); /*10 */ /*11 */ /*12 */ /*13 */ /*14 */ /*15 */ /*16 */ /*17 */ /*18 */ = 0, linkeGrenzsumme = 0; } public static int maxSubsum3(int a[]) { return maxSubsum(a, 0, a.length - 1); } Die Anwendung des Lösungsverfahrens auf das Implementierung mit dem Leistungsverhalten O(NlogN). Max-Subarray-Problem führt zu einer 4. Lösung: Implementierung mit dem Leistungsverhalten O(N) Die Positionen 0,..,N-1 der Eingabefolge bilden eine aufsteigend sortierte, lineare Folge von Inspektionsstellen (oder: Ereignispunkten). Man durchläuft die Eingabe in der durch die Inspektionsstelleb vorgegebenen Reihenfolge und führt zugleich eine vom jeweiligen Problem abhängige, dynamisch veränderliche, d.h. an jeder Informationsstelle gegebenenfalls zu korrigierende Information mit. Im vorliegenden Fall ist das die maximale Summe einer Teilfolge (maxSumme) im gesamten bisher inspizierten Anfangsteil und das an der Inspektionstelle endende rechte Randmaximum (summe) des bisher inspizierten Anfangsstücks. public static int maxSubsum4(int a[]) { /* 1 */ int maxSumme = 0, summe = 0; /* 2 */ for (int j = 0; j < a.length; j++) { /* 3 */ summe += a[j]; /* 4 */ if (summe > maxSumme) /* 5 */ maxSumme = summe; /* 6 */ else if (summe < 0) /* 7 */ summe = 0; } /* 8 */ return maxSumme; } Das ist ein Algorithmus, der in linearer Zeit ausführbar ist. Zur Bestimmung der maximalen Teilfolge müssen alle Folgeelemente wenigstens einmal betrachtet werden. Das sind insgesamt N Schritte. 31 Algorithmen und Datenstrukturen 1.2.7.2 O(logN)-Algorithmen Gelingt es die Problemgröße in konstanter Zeit (O(1)) zu halbieren, dann zeigt der zugehörige Algorithmus das Leistungsverhalten O(logN)). Nur spezielle Probleme können dieses Leistungsverhalten erreichen. Binäre Suche Aufgabe: Gegeben ist eine Zahl X und eine sortiert vorliegenden Folge von Ganzzahlen A0, A1, A2, ... , AN-1 im Arbeitsspeicher. Finde die Position i so, daß Ai=X bzw. gib i=-1 zurück, wenn X nicht gefunden wurde. Implementierung public static int binaereSuche(Comparable a[], Comparable x) { /* 1 */ int links = 0, rechts = a.length - 1; /* 2 */ while (links < rechts) { /* 3 */ int mitte = (links + rechts) / 2; /* 4 */ if (a[mitte].compareTo(x) < 0) /* 5 */ links = mitte + 1; /* 6 */ else if (a[mitte].compareTo(x) > 0) /* 7 */ rechts = mitte - 1; else /* 8 */ return mitte; // Gefunden } /* 9 */ return -1; // Nicht gefunden } Leistungsanalyse: Entscheidend für das Leistungsverhalten ist die Schleife (/* 2 */. Sie beginnt mit (rechts – links) = N-1 und endet mit (rechts – links) = -1. Bei jedem Schleifendurchgang muß (rechts – links) halbiert werden. Ist bspw. (rechts – links) = 128, dann sind die maximalen Werte nach jeder Iteration: 64, 32, 16, 8, 4, 2, 1, 0, -1. Die Laufzeit läßt sich demnach in der Größenordnung O(logN) sehen. Die binäre Suche ist eine Implementierung eines Algorithmus für eine Datenstruktur (sequentiell gespeicherte Liste, Array). Zum Aufsuchen von Datenelementen wird eine Zeit von O(logN) verbraucht. Alle anderen Operationen (z.B. Einfügen) nehmen ein Leistungsverhalten von O(N) in Anspruch. 1.2.7.3 Berechnungsgrundlagen für rechnerische Komplexität System-Effizienz und rechnerische Effizienz Effiziente Algorithmen zeichnen sich aus durch - schnelle Bearbeitungsfolgen (Systemeffizienz) auf unterschiedliche Rechnersystemen. Hier wird die Laufzeit der diversen Suchalgorithmen auf dem Rechner (bzw. verschiedene Rechnersysteme) ermittelt und miteinander verglichen. Die zeitliche Beanspruchung wird über die interne Systemuhr gemessen und ist abhängig vom Rechnertyp - Inanspruchnahme von möglichst wenig (Arbeits-) Speicher - Optimierung wichtiger Leistungsmerkmale, z.B. die Anzahl der Vergleichsbedingungen, die Anzahl der Iterationen, die Anzahl der Anweisungen (, die der Algorithmus benutzt). Die 32 Algorithmen und Datenstrukturen Berechnungskriterien bestimmen die sog. rechnerische Komplexität in einer Datensammlung. Man spricht auch von der rechnerischen Effizienz. P- bzw. NP-Probleme: Von besonderem Interesse für die Praxis ist der Unterschied zwischen Problemen mit polynomialer Laufzeit (d.h. T ( N ) = O ( p ( N )) , p = Polynom in N) und solchen mit nicht polynomialer Laufzeit. Probleme mit polynomialer Laufzeit nennt man leicht, alle übrigen Probleme heißen hart (oder unzugänglich). Harte Probleme sind praktisch nicht mehr (wohl aber theoretisch) algorithmisch lösbar, denn selbst für kleine Eingaben benötigt ein derartiger Algorithmus Rechenzeit, die nicht mehr zumutbar ist und leicht ein Menschenalter überschreitet 24. Viele wichtige Problemlösungsverfahren liegen in dem Bereich zwischen leichten und harten Problemen.. Man kann nicht zeigen, dass diese Probleme leicht sind, denn es gibt für sie keinen Polynomialzeit-Algorithmus. Umgekehrt kann man auch nicht sagen, dass es sich um harte Probleme handelt. Der Fakt, dass kein PolynomialzeitAlgorithmus gefunden wurde, schließt die Existenz eines solchem Algorithmus nicht aus. Möglicherweise hat man sich bei der Suche danach bisher noch nicht klug genug angestellt. Es wird dann nach seit Jahrzenten erfogloser Forschung angenommen, dass es für diese Probleme keine polynomiellen Algorithmen gibt. Man spricht in diesem Fall von der Klasse der sog. NP-vollständigen Probleme. 25 Es ist heute allgemeine Überzeugung, daß höchstens solche Algorithmen praktikabel sind, deren Laufzeit durch ein Polynom in der Problemgröße beschränkt bleibt. Algorithmen, die exponentielle Schrittzahl erfordern, sind schon für relativ kleine Problemgrößen nicht mehr ausführbar. Berechnungsgrundlagen für rechnerische Komplexität: Generell kann man für Algorithmen folgende Grenzfälle bzgl. der Rechenbarkeit beobachten: - kombinatorische Explosion Es gibt eine Reihe von klassischen Problemen, die immer wieder in der Mathematik oder der DVLiteratur auftauchen, weil sie knapp darzustellen und im Prinzip einfach zu verstehen sind. Manche von ihnen sind nur von theoretischen Interesse, wie etwa die Türme von Hanoi. Ein anderes klassisches Problem ist dagegen das Problem des Handlungsreisenden 26 (Travelling Salesman Problem, TSP). Es besteht darin, daß ein Handlungsreisender eine Rundreise zwischen einer Reihe von Städten machen soll, wobei er am Ende wieder am Abfahrtort ankommt. Dabei will er den Aufwand (gefahrene Kilometer, gesamte Reisezeit, Eisenbahn- oder Flugkosten, je nach dem jeweiligen Optimierungswunsch) minimieren. So zeigt bspw. die folgende Entfernungstabelle die zu besuchenden Städte und die Kilometer zwischen ihnen: München Frankfurt Heidelberg Karlsruhe Mannheim Frankfurt 395 - Heidelberg 333 95 - Karlsruhe 287 143 54 - Mannheim 347 88 21 68 - Wiesbaden 427 32 103 150 92 Grundsätzlich (und bei wenigen Städten, wie in diesem Bsp., auch tatsächlich) ist die exakte Lösung dieser Optimierungsaufgabe mit einem trivialen Suchalgorithmus zu erledigen. Man rechnet sich einfach die Route der Gesamtstrecke aus und wählt die kürzeste. Der benötigte Rechenaufwand steigt mit der Zahl N der zu besuchenden Städte sprunghaft an. Erhöht man bspw. N von 5 auf 10, so verlängert sich die Rechenzeit etwa auf das „dreißigtausendfache“. Dies nennt man kombinatorische Explosion, weil der Suchprozeß jede mögliche Kombination der 24 vgl. Abb. 1.2-2 nichtdeterministisch polynomial 26 Vorbild für viele Optimierungsaufgaben, wie sie vor allem im Operations Research immer wieder vorkommen. 25 33 Algorithmen und Datenstrukturen für das Problem relevanten Objekte einzeln durchprobieren muß. Der Aufwand steigt proportional zur Fakultät (N!). - exponentielle Explosion Wie kann man die vollständige Prüfung aller möglichen Kombinationen und damit die kombinatorische Explosion umgehen? Naheliegend für das TSP ist, nicht alle möglichen Routen zu berechnen und erst dann die optimale zu suchen, sondern sich immer die bis jetzt beste zu merken und das Ausprobieren einer neuen Wegkombination sofort abzubrechen, wenn bereits eine Teilstrecke zu größeren Kilometerzahlen führt als das bisherige Optimum, z.B.: Route 1 München Karlsruhe Heidelberg Mannheim Wiesbaden Frankfurt München Streckensumme 0 287 341 362 454 486 881 Route 2 München Wiesbaden Karlsruhe Frankfurt Heidelberg Streckensumme 0 429 722 865 960 Route 2 kann abgebrochen werden, weil die Teilstrecke der Route 2 (960) bereits länger ist als die Gesamtstrecke der Route 1. Diese Verbesserung vermeidet die kombinatorische Explosion, ersetzt sie aber leider nur durch die etwas schwächere exponentielle Explosion. Die Rechenzeit nimmt exponetiell, d.h. mit aN für irgendeinen problemspezifischen Wert zu. Im vorliegenden Fall ist a etwa 1.26. - polynomiales Zeitverhalten In der Regel ist polynomiales Zeitverhalten das beste, auf das man hoffen kann. Hiervon redet man, wenn man die benötigte Rechenzeit durch ein Polynom T = a n N + ... + a 2 N + a1 N + a 0 n 2 ausgedrückt werden. „N“ ist bestimmt durch die zu suchenden problemspezifischen Werte, n beschreibt den Exponenten. Da gegen das erste Glied mit der höchsten Potenz bei größeren Objektzahlen alle anderen Terme des Ausdrucks vernachlässigt werden können, klassifiziert man das polynomiale Zeitverhalten nach dieser höchsten Potenz. Man sagt, ein Verfahren zeigt polynomiales Zeitverhalten O(Nn), falls die benötigte Rechenzeit mit der nten Potenz der Zahl der zu bearbeitenden Objekte anwächst. Die einzigen bekannten Lösungen des TSP, die in polynomialer Zeit ablaufen, verzichten darauf, unter allen Umständen die beste Lösung zu finden, sondern geben sich mit einer recht guten Lösung zufrieden. In der Fachsprache wird das so ausgedrückt, daß das TSP NP-vollständig sei. Das bedeutet: In polynomialer Zeit kann nur eine nichtdeterministische Lösung berechnet werden, also eine, die nicht immer deterministisch ein und dasselbe (optimale) Ergebnis findet. Ein Verfahren, für das nicht garantiert werden kann, daß es in allen Fällen ein exaktes Resultat liefert, wird heuristisch genannt. Eine naheliegende heuristische Lösung für das TSP ist der „Nächste Nachbarn-Algorithmus“. Er beginnt die Route mit der Stadt, die am nächsten zum Ausgangsort liegt und setzt sie immer mit derjenigen noch nicht besuchten Stadt fort, die wiederum die nächste zum jeweiligen Aufenthaltsort ist. Da in jeder der N Städte alle (d.h. im Durchschnitt (N-1)/2) noch nicht besuchte Orte nach dem nächsten benachbarten durchsucht werden müssen, ist der Teitaufwand für 2 das Durchsuchen proportional N ⋅ ( N − 1) / 2 , d.h. O(N ), und damit polynomial „in quadratischer Zeit“ Die meisten Algorithmen für Datenstrukturen bewegen sich in einem schmalen Band rechnerischer Komplexität. So ist ein Algorithmus von der Ordnung O(1) unabhängig von der Anzahl der Datenelemente in der Datensammlung. Der Algorithmus läuft unter konstanter Zeit ab, z.B.: Das Suchen des zuletzt in eine Schlange eingefügten Elements bzw. die Suche des Topelements in einem Stapel. 34 Algorithmen und Datenstrukturen Ein Algorithmus mit dem Verhalten O(N) ist linear. Zeitlich verhält er sich proportional zur Größe der Liste. Bsp.: Das Bestimmen des größten Elements in einer Liste. Es sind N Elemente zu überprüfen, bevor das Ende der Liste erkannt wird. Andere Algorithmen zeigen „logarithmisches Verhalten“. Ein solches Verhalten läßt sich beobachten, falls Teildaten die Größe einer Liste auf die Hälfte, ein Viertel, ein Achtel... reduzieren. Die Lösungssuche ist dann auf die Teilliste beschränkt. Derartiges Verhalten findet sich bei der Behandlung binärer Bäume bzw. tritt auf beim „binären Suchen“. Der Algorithmus für binäre Suche zeigt das Verhalten O(log 2 N ) , Sortieralgorithmen wie der Quicksort und Heapsort besitzen eine rechnerische Komplexität von O( N log 2 N ) . Einfache Sortierverfahren (z.B. „BubbleSort“) bestehen aus Algorithmen mit einer Komplexität von O( N 2 ) . Sie sind deshalb auch nur für kleine Datenmengen brauchbar. Algorithmen mit kubischem Verhalten O( N 3 ) sind bereits äußerst langsam (z.B. der Algorithmus von Warshall zur Bearbeitung von Graphen). Ein Algorithmus mit einer Komplexität von O( 2 N ) zeigt exponentielle Komplexität. Ein derartiger Algorithmus ist nur für kleine N auf einem Rechner lauffähig. 1.3 Daten und Datenstrukturen 1.3.1 Datentyp Ein Algorithmus verarbeitet Daten. Ein Datentyp soll gleichartige zusammenfassen und die nötigen Basisoperationen zur Verfügung stellen. Ein Datentyp ist durch 2 Angaben festgelegt: Daten 1. Eine Menge von Daten (Werte) 2. Eine Menge von Operationen auf diesen Daten Ein Datentyp 27ist demnach eine Zusammenfassung von Wertebereichen und Operationen zu einer Einheit. Eine passende Abstraktion für Datentypen sind Algebren. Eine Algebra ist eine Wertemenge plus Operation auf diesen werten. Ein typisches Beispiel für dieses Konzept sind die natürlichen Zahlen mit den Operationen +, -, * ,%, etc. Wertemengen eines Datentyps werden in der Informatik als Sorten bezeichnet. Die Operationen eines Datentyps entsprechen Funktionen und werden durch Algorithmen realisiert, In der Regel liegt eine mehrwertige Algebra vor, also eine Algebra mit mehreren Sorten als Wertebereiche. Bsp.:Natürliche Zahlen plus Wahrheitswerte mit den Operationen +, -, *, % auf zahlen, ¬, ∧, ∨ ,... auf Wahrheitswerten und =, <, > , ≤,... als Verbindung zwischen den Sorten. Signatur von Datentypen. Darunter versteht man eine Formularisierung der Schnittstellenbeschreibung eines Datentyps. Sie besteht aus Angaben der Namen der Sorten und der Operationen. Die Operationen werden neben dem Bezeichner der Operation auch die Stelligkeit der Operanden und der Sorten der einzelnen 27 Vgl. Skriptum Programmieren in Java WS 2005 / 2006: 1.3.4, 1.4.1.3, 2.3 35 Algorithmen und Datenstrukturen Parameter angegeben. Die Konstanten werden als O-stellige Operationen realisert, z.B 28.: typ nat sorts nat, boll functions 0 -> nat succ : nat -> nat + : nat x nat -> nat <= : nat x nat -> bool ….. Datentypen in Java: Datentypen spielen eine wichtige Rolle, da hier eine strenge Typisierung realisiert ist. Datentyp Einfacher (elementarer, primitiver) Typ Wahrheitswerte Zeichentyp - boolean -char Referenztyp numerischer Typ Klassentyp Array-Typ - Integer-Typ -Gleitpunkt-Typ -- byte -- float -- short -- double -- int -- long Abb. 1.3-1: Datentypen in Java 28 Das Beispiel ist angelehnt an die algebraische Spezifikation von Datenstrukturen 36 Schnittstellentyp Algorithmen und Datenstrukturen 1.3.2 Datenstruktur Komplexe Datentypen, sog. Datenstrukturen, werden durch Kombination primitiver Datentypen gebildet. Sie besitzen selbst spezifische Operationen. Eine Datenstruktur ist ein Datentyp und dient zur Organisation von Daten zur effizienten Unterstützung bestimmter Operationen. Betrachtet wird ein Ausschnitt aus der realen Welt, z.B. die Hörer dieser Vorlesung an einem bestimmten Tag: Juergen Josef Liesel Maria ........ Regensburg ......... ......... ......... ......... Bad Hersfeld ......... ......... ......... ......... 13.11.70 ........ ........ ........ ........ Friedrich-. Ebertstr. 14 .......... .......... .......... .......... Diese Daten können sich zeitlich ändern, z.B. eine Woche später kann eine veränderte Zusammensetzung der Zuhörerschaft vorliegen. Es ist aber deutlich erkennbar: Die Modelldaten entsprechen einem zeitinvarianten Schema: NAME WOHNORT GEBURTSORT GEB.-DATUM STRASSE Diese Feststellung entspricht einem Abstraktionsprozeß und führt zur Datenstruktur. Sie bestimmt den Rahmen (Schema) für die Beschreibung eines Datenbestandes. Der Datenbestand ist dann eine Ansammlung von Datenelementen (Knoten), der Knotentyp ist durch das Schema festgelegt. Der Wert eines Knoten k ∈ K wird mit wk bezeichnet und ist ein n ≥ 0 -Tupel von Zeichenfolgen; w i k bezeichnet die i-te Komponente des Knoten. Es gilt wk = ( w1k , w2 k ,...., wn k ) Die Knotenwerte des vorstehenden Beispiels sind: wk1 = (Jürgen____,Regensburg,Bad Hersfeld,....__,Ulmenweg__) wk2 = (Josef_____,Straubing_,......______,....__,........__) wk3 = (Liesel____,....._____,......______,....__,........__) .......... wkn = (__________,__________,____________,______,__________) Welche Operationen sind mit dieser Datenstruktur möglich? Bei der vorliegenden Tabelle sind z.B. Zugriffsfunktionen zum Einfügen, Löschen und Ändern eines Tabelleneintrages mögliche Operationen. Generell bestimmen Datenstrukturen auch die Operationen, die mit diesen Strukturen ausgeführt werden dürfen. Zusammenhänge zwischen den Knoten eines Datenbestandes lassen sich mit Hilfe von Relationen bequem darstellen. Den vorliegenden Datenbestand wird man aus Verarbeitungsgründen bspw. nach einem bestimmten Merkmal anordnen (Ordnungsrelation). Dafür steht hier (im vorliegenden Beispiel) der Name der Studenten: 37 Algorithmen und Datenstrukturen Josef Juergen Liesel Abb. 1.3-2: Einfacher Zusammenhang zwischen Knoten eines Datenbestandes Datenstrukturen bestehen also aus Knoten(den einzelnen Datenobjekten) und Relationen (Verbindungen). Die Verbindungen bestimmen die Struktur des Datenbestandes. Bsp.: 1. An Bayerischen Fachhochschulen sind im Hauptstudium mindestens 2 allgemeinwissenschaftliche Wahlfächer zu absolvieren. Zwischen den einzelnen Fächern, den Dozenten, die diese Fächer betreuen, und den Studenten bestehen Verbindungen. Die Objektmengen der Studenten und die der Dozenten ist nach den Namen sortiert (geordnet). Die Datenstruktur, aus der hervorgeht, welche Vorlesungen die Studenten bei welchen Dozenten hören, ist: 38 Algorithmen und Datenstrukturen STUDENT FACH DATEN DOZENT DATEN DATEN DATEN DATEN DATEN DATEN DATEN DATEN DATEN geordnet (z.B. nach Matrikelnummern) geordnet (z.B. nach Titel im Vorlesungsverzeichnis) geordnet (z.B. nach Namen) Abb. 1.3-3: Komplexer Zusammenhang zwischen den Knoten eines Datenbestands 2. Ein Gerät soll sich in folgender Form aus verschiedenen Teilen zusammensetzen: Anfangszeiger Analyse Anfangszeiger Vorrat G1, 5 B2, 4 B1, 3 B3, 2 B4, 1 Abb. 1.3-4: Darstellung der Zusammensetzung eines Geräts 39 Algorithmen und Datenstrukturen 2 Relationen können hier unterschieden werden: 1) Beziehungsverhältnisse eines Knoten zu seinen unmittelbaren Nachfolgeknoten. Die Relation Analyse beschreibt den Aufbau eines Gerätes 2) Die Relation Vorrat gibt die Knoten mit w2k <= 3 an. Die Beschreibung eines Geräts erfordert in der Praxis eine weit komplexere Datenstruktur (größere Knotenzahl, zusätzliche Relationen). 3. Eine Bibliotheksverwaltung soll angeben, welches Buch welcher Student entliehen hat. Es ist ausreichend, Bücher mit dem Namen des Verfassers (z.B. „Stroustrup“) und die Entleiher mit ihrem Vornamen (z.B. „Juergen“, „Josef“) anzugeben. Damit kann die Bibliotheksverwaltung Aussagen, z.B. „Josef hat Stroustrup ausgeliehen“ oder „Juergen hat Goldberg zurückgegeben“ bzw. Fragen, z.B. „welche Bücher hat Juergen ausgeliehen?“, realisieren. In die Bibliothek sind Objekte aufzunehmen, die Bücher repäsentieren, z.B.: Buch „Stroustrup“ Weiterhin muß es Objekte geben, die Personen repräsentieren, z.B.: Person „Juergen“ Falls „Juergen“ Stroustrup“ ausleiht, ergibt sich folgende Darstellung: Person „Juergen“ Buch „Stroustrup“ Abb. 1.3-5: Objekte und ihre Beziehung in der Bibliotheksverwaltung Der Pfeil von „Stroustrup“ nach „Juergen“ zeigt: „Juergen“ ist der Entleiher von „Stroustrup“, der Pfeil von „Juergen“ nach „Stroustrup“ besagt: „Stroustrup“ ist eines der von „Juergen“ entliehenen Bücher. Für mehrere Personen kann sich folgende Darstellung ergeben: 40 Algorithmen und Datenstrukturen Person Person „Juergen“ Person „Josef“ Buch Buch „Stroustrup“ „Goldberg“ Buch „Lippman“ Abb. 1.3-6: Objektverknüpfungen in der Bibliotheksverwaltung Zur Verbindung der Klasse „Person“ bzw. „Buch“ wird eine Verbindungsstruktur benötigt: Person buecher = Verbindungsstruktur „Juergen“ Buch „Stroustrup“ Abb. 1.3-7: Verbindungsstruktur zwischen den Objekttypen „Person“ und „Buch“ Ein bestimmtes Problem kann auf vielfätige Art in Rechnersystemen abgebildet werden. So kann das vorliegende Problem über verkettete Listen im Arbeitsspeicher oder auf Externspeicher (Dateien) realisiert werden. Die vorliegenden Beispiele können folgendermaßen zusammengefaßt werden: Die Verkörperung einer Datenstruktur wird durch das Paar D = (K,R) definiert. K ist die Knotenmenge (Objektmenge) und R ist eine endliche Menge von binären Relationen über K. 41 Algorithmen und Datenstrukturen 1.3.3 Relationen und Ordnungen Relationen Zusammenhänge zwischen den Knoten eines Datenbestandes lassen sich mit Hilfe von Relationen bequem darstellen. Eine Relation ist bspw. in folgender Form gegeben: R = {(1,2),(1,3),(2,4),(2,5),(2,6),(3,5),(3,7),(5,7),(6,7)} Diese Relation bezeichnet eine Menge geordneter Paare oder eine Produktmenge M × N . Sind M und N also Mengen, dann nennt man jede Teilmenge M × N eine zweistellige oder binäre Relation über M × N (oder nur über M , wenn M = N ist). Jede binäre Relation auf einer Produktmenge kann durch einen Graphen dargestellt werden, z.B.: 1 3 2 5 6 4 7 Abb. 1.3-8: Ein Graph zur Darstellung einer binären Relation Bsp.: Gegeben ist S (eine Menge der Studenten) und V (eine Menge von Vorlesungen). Die Beziehung ist: x ∈ S hört y ∈V . Diese Beziehung kann man durch die Angabe aller Paare ( x , y ) beschreiben, für die gilt: Student x hört Vorlesung y . Jedes dieser Paare ist Element des kartesischen Produkts S × V der Mengen S und V. Für Relationen sind aus der Mathematik folgende Erklärungen bekannt: 1. Vorgänger und Nachfolger R ist eine Relation über der Menge M. Gilt ( a , b ) ∈ R , dann sagt man: „a ist Vorgänger von b, b ist Nachfolger von a“. Zweckmäßigerweise unterscheidet man in diesem Zusammenhang auch den Definitions- und Bildbereich Def(R) = { x | ( x , y ) ∈ R } Bild(R) = { y | ( x , y ) ∈ R } 2. Inverse Relation (Umkehrrelation) 42 Algorithmen und Datenstrukturen Relationen sind umkehrbar. Die Beziehungen zwischen 2 Grössen x und y können auch als Beziehung zwischen y und x dargestellt werden, z.B.: Aus „x ist Vater von y“ wird durch Umkehrung „y ist Sohn von x“. Allgemein gilt: R-1 = { (y,x) | ( x , y ) ∈ R } 3. Reflexive Relation ∀ ( x , x ) ∈ R (Für alle Elemente x aus M gilt, x steht in Relation zu x) x ∈M Beschreibt man bspw. die Relation "... ist Teiler von ..." für die Menge M = {2,4,6,12} in einem Grafen, so erhält man: 12 4 6 2 Abb. 1.3-9: Die binäre Relation „... ist Teiler von ... “ Alle Pfeile, die von einer bestimmten Zahl ausgehen und wieder auf diese Zahl verweisen, sind Kennzeichen einer reflexiven Relation ( in der Darstellung sind das Schleifen). Eine Relation, die nicht reflexiv ist, ist antireflexiv oder irreflexiv. 4. Symmetrische Relation Aus (( ( x , y ) ∈ R ) folgt auch (( ( y , x ) ∈ R ). Das läßt sich auch so schreiben: Wenn ein geordnetes Paar (x,y) der Relation R angehört, dann gehört auch das umgekehrte Paar (y,x) ebenfalls dieser Relation an. Bsp.: a) g ist parallel zu h h ist parallel zu g b) g ist senkrecht zu h h ist senkrecht zu g 5. Asymmetrische Relation Solche Relationen sind auch aus dem täglichen Leben bekannt. Es gilt bspw. „x ist Vater von y“ aber nicht gleichzeitig „y ist Vater von x“. Eine binäre Relation ist unter folgenden Bedingungen streng asymetrisch: ∀ ( x , y ) ∈ R → (( y , x ) ∉ R ) ( x , y )∈R 43 Algorithmen und Datenstrukturen Das läßt sich auch so ausdrücken: Gehört das geordnete Paar (x,y) zur Relation, so gehört das entgegengesetzte Paar (y,x) nicht zur Relation. Gilt für x <> y die vorstehende Relation und für x = y ∀( x , x ) ∈ R , so wird diese binäre Relation "unstreng asymmetrisch" oder "antisymmetrisch" genannt. 6. Transitive Relation Eine binäre Relation ist transitiv, wenn (( ( x , y ) ∈ R ) und (( ( y , z ) ∈ R ) ist, dann ist auch (( ( x , z ) ∈ R ). x hat also y zur Folge und y hat z zur Folge. Somit hat x auch z zur Folge. 7. Äquivalenzrelation Eine binäre Relation ist eine Äquivalenzrelation, wenn sie folgenden Eigenschaften entspricht: - Reflexivität - Transitivität - Symmetrie Bsp.: Die Beziehung "... ist ebenso gross wie ..." ist eine Äquivalenzrelation. 1. Wenn x1 ebenso groß ist wie x2, dann ist x2 ebenso groß wie x1. Die Relation ist symmetrisch. 2. x1 ist ebenso groß wie x1. Die Relation ist reflexiv. 3. Wenn x1 ebenso groß wie x2 und x2 ebenso gross ist wie x3, dann ist x1 ebenso groß wie x3. Die Relation ist transitiv. Klasseneinteilung - Ist eine Äquivalenzrelation R in einer Menge M erklärt, so ist M in Klassen eingeteilt - Jede Klasse enthält Elemente aus M, die untereinander äquivalent sind - Die Einteilung in Klassen beruht auf Mengen M1, M2, ... , Mx, ... , My Für die Teilmengen gilt: Mx ∩ M y = 0 (2) M1 ∪ M 2 ∪....∪ M y = M (1) (3) Mx <> 0 (keine Teilmenge ist die leere Menge) Bsp.: Klasseneinteilungen können sein: - Die Menge der Studenten der FH Regensburg: Äquivalenzrelation "... ist im gleichen Semester wie ..." - Die Menge aller Einwohner einer Stadt in die Klassen der Einwohner, die in der-selben Straße wohnen: Äquivalenzrelation ".. wohnt in der gleichen Strasse wie .." Aufgabe 1. Welche der folgenden Relationen sind transitiv bzw. nicht transitiv? 1) 2) 3) 4) 5) ... ... ... ... ... ist ist ist ist ist der Teiler von .... der Kamerad von ... Bruder von ... deckungsgleich mit ... senkrecht zu ... (transitiv) (transitiv) (transitiv) (transitiv) (nicht transitiv) 2. Welche der folgenden Relationen sind Aequivalenzrelationen? 1) 2) 3) 4) ... ... ... ... gehört dem gleichen Sportverein an ... hat denselben Geburtsort wie ... wohnt in derselben Stadt wie ... hat diesselbe Anzahl von Söhnen 44 Algorithmen und Datenstrukturen Ordnungen 1. Halbordnung Eine binäre Relation ist eine "Halbordnung", wenn sie folgende Eigenschaften besitzt: "Reflexivität, Transitivität" 2. Strenge Ordnungsrelation Eine binäre Relation ist eine "strenge Ordnungsrelation", wenn sie folgende Eigenschaft besitzt: "Transitivität, Asymmetrie" 3. Unstrenge Ordnungsrelation Eine binäre Relation ist eine "unstrenge Ordnungsrelation", wenn sie folgende Eigenschaften besitzt: Transitivität, unstrenge Asymmetrie 4. Totale Ordnungsrelation und partielle Ordnungsrelation Tritt in der Ordnungsrelation x vor y auf, so verwendet man das Symbol < (x < y). Vergleicht man die Abb. 1.2-9, so kann man für (1) schreiben: e < a < b < d und c < d Das Element c kann man weder mit den Elementen e, a noch mit b in eine gemeinsame Ordnung bringen. Daher bezeichnet man diese Ordnungsrelation als partielle Ordnung (teilweise Ordnung). Eine totale Ordnungsrelation enthält im Gegensatz dazu Abb. 1.2-9 in (2): e < a < b<c<d Kann also jedes Element hinsichtlich aller anderen Elemente geordnet werden, so ist die Ordnungsrelation eine totale, andernfalls heißt sie partiell. (1) (2) a a b e e b d c d Abb.1.3-10: Totale und partielle Ordnungsrelationen 45 c Algorithmen und Datenstrukturen 5. „Natürliche Ordnungsbeziehungen“ in Java Das Comparable Interface aus dem Paket java.lang dient zum Herstellen „natürlicher Ordnungsbeziehungen“: /**************** Comparable.java ***************************** /** Das Interface deklariert eine Methode anhand der sich das * das aufgerufene Objekt mit dem uebergebenen vergleicht. * Fuer jeden vom Objekt abgeleiteten Datentyp muss eine solche * Vergleichsklasse implementiert werden. * Die Methode erzeugt eine Fehlermeldung, wenn "a" ein Objekt * einer anderen Klasse als dieses Objekt ist. * * int compareTo(Comparable a) * liefert 0, wenn this == 0 * liefert < 0, wenn this < a * liefert > 0, wenn this > a * */ public interface Comparable { public int compareTo(Comparable a); } Seit dem JDK 1.2 wird das Comparable Interface bereits von vielen eingebauten Klassen implementiert, etwa von String, Character, Double, usw. Die natürliche Ordnung ergibt sich, indem man alle Elemente paarweise miteinander vergleicht und dabei jeweils das kleinere vor der größere Element stellt. Besitzt eine Klasse das Interface Comparable nicht, dann kann auch eine Implementierung des Interface Comparator vorgesehen werden. /**************** Comparator.java ***************************** /** Das Interface deklariert zwei Methoden zur Durchfuehrung von * Vergleichen. * Die Methode equals() führt auf den Rückgabewert true bzw. false, * je nachdem ob this == o ist. * compare() hat folgende Rückgabewerte: * Falls das erste Element vor dem zweiten Element kommt, * ist der Rückgabewert negativ. * Falls das erste Element nach dem zweiten Element kommt, * ist der Rückgabewert positiv * Der Rückgabewert 0 signalisiert, dass die beiden Elemente an * der gleichen Ordnungsposition eingeordnet werden. */ public interface Comparator { public int compare(Object element1, Object element2); public boolean equals(Object o); } 46 Algorithmen und Datenstrukturen 1.3.4 Klassifikation von Datenstrukturen Eine Datenstruktur ist ein Datentyp mit folgenden Eigenschaften 1. Sie besteht aus mehreren Datenelementen. Diese können - atomare Datentypen oder selbst Datenstrukturen sein 2. Sie setzt die Elemente durch eine Menge von Regeln (eine Struktur) in eine Beziehung (Relation). Elementare Strukturrelationen Menge lineare Struktur (gerichtete 1:1-Relation) Baum (hierarchisch) (gerichtete 1 : n – Relation) Graph (Netzwerk) ( n : m Relation) Abb. 1.3.-11: Elementare Datenstrukturen Eine Datenstruktur ist durch Anzahl und Eigenschaften der Relationen bestimmt. Obwohl sehr viele Relationstypen denkbar sind, gibt es nur 4 fundamentale Datenstrukturen 29, die immer wieder verwendet werden und auf die andere Datenstrukturen zurückgeführt werden können. Den 4 Datenstrukturen ist gemeinsam, daß sie nur binäre Relationen verwenden. 1.3.4.1 Lineare Ordnungsgruppen Sie sind über eine (oder mehrere) totale Ordnung(en) definiert. Die bekanntesten Verkörperungen der linearen Ordnung sind: - (ein- oder mehrdimensionale) Felder (lineare Felder) - Stapel - Schlangen - lineare Listen Lineare Ordnungsgruppen können sequentiell (seqentiell gespeichert) bzw. verkettet (verkettet gespeichert) angeordnet werden. 29 nach: Rembold, Ulrich (Hrsg.): "Einführung in die Informatik", München/Wien, 1987 47 Algorithmen und Datenstrukturen 1. Sammlungen mit direktem Zugriff Ein „array“ (Reihung) ist eine Sammlung von Komponenten desselben Typs, auf den direkt zugegriffen werden kann. „array“-Kollektion Daten Eine Kollektion von Objekten desselben (einheitlichen) Typs Operationen Die Daten an jeder Stelle des „array“ können über einen ganzzahligen Index erreicht werden. Ein statisches Feld („array“) enthält eine feste Anzahl von Elementen und ist zur Übersetzungszeit festgelegt. Ein dynamisches Feld benutzt Techniken zur Speicherbeschaffung und kann während der Laufzeit an die Gegebenheiten angepaßt werden. Ein „array“ kann zur Speicherung einer Liste herangezogen werden. Allerdings können Elemente der Liste nur effizient am Ende des „array“ eingefügt werden. Anderenfalls sind für spezielle Einfügeoperationen Verschiebungen der bereits vorliegenden Elemente (ab Einfügeposition) nötig. Eine „array“-Klasse sollte Bereichsgrenzenüberwachung für Indexe und dynamische Erweiterungsmöglichkeiten erhalten. Implementierungen aktueller Programmiersprachen umfassen Array-Klassen mit nützlichen Bearbeitungsmethoden bzw. mit dynamischer Anpassung der Bereichsgrenzen zur Laufzeit. Eine Zeichenkette („character string“) ist ein spezialisierter „array“, dessen Elemente aus Zeichen bestehen: „character string“-Kollektion Daten Eine Zusammenstellung von Zeichen in bekannter Länge Operationen Sie umfassen Bestimmen der Länge der Zeichenkette, Kopieren bzw. Verketten einer Zeichenkette auf eine bzw. mit einer anderen Zeichenkette, Vergleich zweier Zeichenketten (für die Musterverarbeitung), Ein-, Ausgabe von Zeichenketten In einem „array“ kann ein Element über einen Index direkt angesprochen werden. In vielen Anwendungen ist ein spezifisches Datenelement, der Schlüssel (key) für den Zugriff auf einen Datensatz vorgesehen. Behälter, die Schlüssel und übrige Datenelemente zusammen aufnehmen, sind Tabellen. Ein Dictionary ist eine Menge von Elementen, die über einen Schlüssel identifiziert werden. Das Paar aus Schlüsseln und zugeordnetem Wert heißt Assoziation, man spricht auch von „assoziativen Arrays“. Derartige Tabellen ermöglichen den Direktzugriff über Schlüssel so, wie in einem Array der Direktzugriff über den Index erreicht wird, z.B.: Die Klasse Hashtable in Java Der Verbund (record) ist in der Regel eine Zusammenfassung von Datenbehältern unterschiedlichen Typs: „record“-Kollektion Daten 48 Algorithmen und Datenstrukturen Ein Element mit einer Sammlung von Datenfeldern mit möglicherweise unterschiedlichen Typen. Operationen Der Operator . ist für den Direktzugriff auf den Datenbehälter vorgesehen. Eine Datei (file) ist eine extern eingerichtete Sammlung, die mit einer Datenstruktur („stream“) genannt verknüpft wird. „file“-Kollektion Daten Eine Folge von Bytes, die auf einem externen Gerät abgelegt ist. Die Daten fließen wie ein Strom von und zum Gerät. Operationen Öffnen (open) der Datei, einlesen der Daten aus der Datei, schreiben der Daten in die Datei, aufsuchen (seek) eines bestimmten Punkts in der Datei (Direktzugriff) und schließen (close) der Datei. Bsp.: Die RandomAccessFile-Klasse in Java 30 dient zum Zugriff auf RandomAccess-Dateien. 2. Sammlungen mit sequentiellem Zugriff Darunter versteht man lineare Listen (linear list), die Daten in sequentieller Anordnung aufnehmen: „list“-Kollektion Daten Ein meist größere Objektsammlung von Daten gleichen Typs. Operationen Das Durchlaufen der Liste mit Zugriff auf die einzelnen Elemente beginnt an einem Anfangspunkt, schreitet danach von Element zu Element fort bis der gewünschte Ort erreicht ist. Operationen zum Einfügen und Löschen verändern die Größe der Liste. Stapel (stack) und Schlangen (queue) 31 sind spezielle Versionen linearer Listen, deren Zugriffsmöglichkeiten eingeschränkt sind. „Stapel“-Kollektion Daten Eine Liste mit Elementen, auf die man nur über die Spitze („top“) zugreifen kann. Operationen Unterstützt werden „push“ und „pop“. „push“ fügt ein neues Element an der Spitze der Liste hinzu, „pop“ entfernt ein Element von der Spitze („top“) der Liste. „Schlange“-Kollektion 30 Implementiert das Interface DataInput und DataOutput mit eigenen Methoden. http://www.galileocomputing.de/openbook/javainsel7/javainsel_12_007.htm Stand: März 2008 31 49 Algorithmen und Datenstrukturen Daten Eine Sammlung von Elementen mit Zugriff am Anfang und Ende der Liste. Operationen Ein Element wird am Ende der Liste hinzugefügt und am Ende der Liste entfernt. Eine Schlange ist besonders geeignet zur Verwaltung von „Wartelisten“ und kann zur Simulation von Wartesystemen eingesetzt werden. Eine Schlange kann ihre Elemente nach Prioritäten bzgl. der Verarbeitung geordnet haben (priority queue) 32. Entfernt wird dann zuerst das Element, das die höchste Priorität besitzt. „prioritätsgesteuerte Schlange“-Kollektion Daten Eine Sammlung von Elementen, von denen jedes Element eine Priorität besitzt. Operationen Hinzufügen von Elementen zur Liste. Entfernt wird immer das Element, das die höchste (oder niedrigste) Priorität besitzt. 1.3.4.2 Nichtlineare Kollektion 1.3.4.2.1 Hierarchische angeordnete Sammlung (Bäume) Bäume sind im wesentlichen durch die Äquivalenzrelation bestimmt. Bsp.: Gliederung zur Vorlesung Algorithmen und Datenstrukturen Algorithmen und Datenstrukturen Kapitel 1: Datenverarbeitung und Datenorganisation Abschnitt 1: Ein einführendes Beispiel Kapitel 2: Suchverfahren Abschnitt 2: Begriffe Abb.: Gliederung zur Vorlesung Datenorganisation Die Verkörperung dieser Vorlesung ist das vorliegende Skriptum. Diese Skriptum {Seite 1, Seite 2, ..... , Seite n} teilt sich in einzelne Kapitel, diese wiederum gliedern sich in Abschnitte. Die folgenden Äquivalenzrelationen definieren diesen Baum: 1. Seite i gehört zum gleichen Kapitel wie Seite j 2. Seite i gehört zum gleichen Abschnitt von Kapitel 1 wie Seite j 3. ........ Die Definitionen eines Baums mit Hilfe von Äquivalenzrelationen regelt ausschließlich "Vorgänger/Nachfolger" - Beziehungen (in vertikaler Richtung) zwischen den Knoten eines Baums. Ein Baum ist auch hinsichtlich der Baumknoten in der 32 http://java.sun.com/j2se/1.5.0/docs/api/java/util/PriorityQueue.html Stand März 2008 50 Algorithmen und Datenstrukturen horizontalen Ebene geordnet, wenn zur Definition des Baums neben der Äquivalenzrelation auch eine partielle Ordnung (Knoten Ki kommt vor Knoten Kj, z.B. Kapitel1 kommt vor Kapitel 2) eingeführt wird. Eine hierarchisch angeordnete Sammlung von Datenbehältern ist gewöhnlich ein Baum mit einem Ursprungs- bzw. Ausgangsknoten, der „Wurzel“ genannt wird. Von besonderer Bedeutung ist eine Baumstruktur, in der jeder Baumknoten zwei Zeiger auf nachfolgende Knoten aufnehmen kann. Diese Binärbaum-Struktur kann mit Hilfe einer speziellen angeordneten Folge der Baumknoten zu einem binären Suchbaum erweitert werden. Binäre Suchbäume bilden die Ausgangsbasis für das Speichern großer Datenmengen. „Baum“-Kollektion Daten Eine hierarchisch angeordnete Ansammlung von Knotenelementen, die von einem Wurzelknoten abgeleitet sind. Jeder Knoten hält Zeiger zu Nachfolgeknoten, die wiederum Wurzeln von Teilbäumen sein können. Operationen Die Baumstruktur erlaubt das Hinzufügen und Löschen von Knoten. Obwohl die Baumstruktur nichtlinear ist, ermöglichen Algorithmen zum Ansteuern der Baumknoten den Zugriff auf die in den Knoten gespeicherten Informationen. Ein „heap“ ist eine spezielle Version, in der das kleinste bzw. größte Element den Wurzelknoten besetzt. Operationen zum Löschen entfernen den Wurzelknoten, dabei wird, wie auch beim Einfügen, der Baum reorganisiert. Basis der Heap-Darstellung ist ein „array“ (Feldbaum), dessen Komponenten eine Binärbaumstruktur überlagert ist. In der folgenden Darstellung ist eine derartige Interpretation durch Markierung der Knotenelemente eines Binärbaums mit Indexpositionen sichtbar: [1] wk1 [2] [3] wk2 wk3 [4] [5] wk4 [8] [0] wk5 [9] wk8 [6] [10] wk9 wk6 [11] wk10 [7] [12] wk11 wk7 [13] wk12 wk13 [14] wk14 [15] wk15 wk1 wk2 wk3 wk4 wk5 wk6 wk7 wk8 wk9 wk10 wk11 wk12 wk13 wk14 wk15 [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] [15] Abb. 1.3-10: Darstellung eines Feldbaums Liegen die Knoten auf den hier in Klammern angegebenen Positionen, so kann man von jeder Position I mit 51 Algorithmen und Datenstrukturen Pl = 2 * I Pr = 2 * I + 1 Pv = I div 2 auf die Position des linken (Pl) und des rechten (Pr) Nachfolgers und des Vorgängers (Pv) gelangen. Ein binärer Baum kann somit in einem eindimensionalen Feld (array) gespeichert werden, falls folgende Relationen eingehalten werden: X[I] <= X[2*I] X[I] <= X[2*I+1] X[1] = min(X[I] .. X[N]) Anstatt auf das kleinste kann auch auf das größte Element Bezug genommen werden Aufbau des Heap: Ausgangspunkt ist ein „array“ mit bspw. folgenden Daten: X[1] 40 X[2] 10 X[3] 30 X[4] ...... , der folgendermaßen interpretiert wird: X[1] 40 X[2] X[3] 10 30 Abb. 1.3-11: Interpretation von Feldinhalten im Rahmen eines binären Baums Durch eine neue Anordnung der Daten in den Feldkomponenten entsteht ein „heap“: X[1] 10 X[2] X[3] 40 30 Abb. 1.3-12: 52 Algorithmen und Datenstrukturen Falls ein neues Element eingefügt wird, dann wird nach dem Ordnen gemäß der „heap“-Bedingung erreicht: X[1] 10 X[2] X[3] 40 30 X[4] 15 X[1] 10 X[2] X[3] 15 30 X[4] 40 Abb.1.3-13: Das Einbringen eines Elements in einen Heap Beim Löschen wird das Wurzelelement an der 1. Position entfernt. Das letzte Element im „heap“ wird dazu benutzt, das Vakuum zu füllen. Anschließend wird reorganisiert: X[1] 10 X[2] X[3] 15 30 X[4] 40 53 Algorithmen und Datenstrukturen X[1] 40 X[2] X[3] 15 30 X[1] 15 X[2] X[3] 40 30 Abb. 1.3-14: Das Löschen eines Elements im Heap Implementierung des Heap in Java 33. // Erzeugung mit optionaler Angabe zur Kapazitaet (Defaultwert: 100) // // ******************PUBLIC OPERATIONEN********************************** // void insert( x ) --> Einfuegen x // Comparable loescheMin( )--> Rueckgabe und entfernen des kleinsten // Elements // Comparable findMin( ) --> Rueckgabe des kleinsten Elements // boolean isEmpty( ) --> Rueckgabe: true, falls leer; anderenfalls // false // boolean isFull( ) --> Rueckgabe true, falls voll; anderenfalls // false // void makeEmpty( ) --> Entfernen aller Elemente Anwendung Der Binary Heap kann zum Sortieren herangezogen werden. Ein Heap kann aber auch in Simulationsprogrammen und vor allem zur Implementierung von Priority Queues verwendet werden. Hier wird vielfach der einfache Heap durch komplexere Datenstrukturen ( Binomial Heap, Fibonacci Heap) ersetzt. 33 Vgl. pr13228 54 Algorithmen und Datenstrukturen 1.3.4.2.2 Gruppenkollektionen Menge (Set) Eine Gruppe umfaßt nichtlineare Kollektionen ohne jegliche Ordnungsbeziehung. Eine Menge (set) einheitlicher Elemente ist. bspw. eine Gruppe. Operationen auf die Kollektion „Set“ umfassen Vereinigung, Differenz und Schnittmengenbildung. „Set“-Kollektion Daten Eine ungeordnete Ansammlung von Objekten ohne Ordnung Operationen Die binäre Operationen über Mitgliedschaft, Vereinigung, Schnittmenge und Differenz bearbeiten die Strukturart „Set“. Weiter Operationen testen auf Teilmengenbeziehungen. Graph Ein Graph (graph) ist eine Datenstruktur, die durch eine Menge Knoten und eine Menge Kanten, die die Knoten verbinden, definiert ist. In seiner einfachsten Form besteht eine Verkörperung dieser Datenstruktur aus einer Knotenmenge K (Objektmenge) und einer festen aber beliebigen Relation R über dieser Menge 34. Die folgende Darstellung zeigt einen Netzplan zur Ermittlung des kritischen Wegs: Die einzelnen Knoten des Graphen sind Anfangs- und Endereignispunkte der Tätigkeiten, die an den Kanten angegeben sind. Die Kanten (Pfeile) beschreiben die Vorgangsdauer und sind Abbildungen binärer Relationen. Zwischen den Knoten liegt eine partielle Ordnungsrelation. Bestelle A 50 Tage Baue B 1 Teste B 4 20 Tage Korrigiere Fehler 2 25 Tage 3 15 Tage Handbucherstellung 60 Tage Abb. 1.3-11: Ein Graph der Netzplantechnik „graph“-Kollektion Daten Eine Menge von Knoten und eine Menge verbindender Kanten. Operationen Der Graph kann Knoten hinzufügen bzw. löschen. Bestimmte Algorithmen starten an einem gegebenen Knoten und finden alle von diesem Knoten aus erreichbaren Knoten. Andere Algorithmen erreichen jeden Knoten im Graphen über „Tiefen“ bzw. „Breiten“ - Suche. 34 vgl. 1.2.2.2, Abb. 1.2-7 55 Algorithmen und Datenstrukturen Ein Netzwerk ist spezielle Form eines Graphen, in dem jede Kante ein bestimmtes Gewicht trägt. Den Gewichten können Kosten, Entfernungen etc. zugeordnet sein. 1.3.4.3 Dateien und Datenbanken Datei Damit ist eine Datenstruktur bestimmt, bei der Verbindungen zwischen den Datenobjekten durch beliebige, binäre Relationen beschrieben werden. Die Anzahl der Relationen ist somit im Gegensatz zur Datenstruktur Graph nicht auf eine beschränkt. Verkörperungen solcher assoziativer Datenstrukturen sind vor allem Dateien. In der Praxis wird statt mehrere binärer Relationen eine n-stellige Relation (Datensatz) gespeichert. Eine Datei ist dann eine Sammlung von Datensätzen gleichen Typs. Bsp.: Studenten-Datei Sie faßt die relevanten Daten der Studenten 35 nach einem ganz bestimmten Schema zusammen. Ein solches Schema beschreibt einen Datensatz. Alle Datensätze, die nach diesem Schema aufgestellt werden, ergeben die Studenten-Datei. Es sind binäre Relationen (Student - Wohnort, Student Geburtsort, ...), die aus Speicheraufwandsgründen zu einer n-stelligen Relation (bezogen auf eine Datei) zusammengefaßt werden. Datenbanken Eine Datenbank ist die Sammlung von verschiedenen Datensatz-Typen. Fachbereich 1 betreut M Student Abb. 1.3-14: „ER“-Diagramm zur Darstellung der Beziehung „Fachbereich-Student“ Auch hier zeigt sich: Knoten bzw. Knotentypen und ihre Beziehungen bzw. Beziehungstypen stehen im Mittelpunkt der Datenbank-Beschreibung. Statt Knoten spricht man hier von Entitäten (bzw. Entitätstypen) und Beziehungen werden Relationen genannt. Dies ist dann Basis für den Entity-Relationship (ER) -Ansatz von P.S. Chen. Zur Beschreibung der Entitätstypen und ihrer Beziehungen benutzt der ER-Ansatz in einem ER-Diagramm rechteckige Kanten bzw. Rauten: Die als „1“ und „M“ an den Kanten aufgeschriebenen Zahlen zeigen: Ein Fachbereich betreut mehrere (viele) Studenten. Solche Beziehungen können vom Typ 1:M, 1:1, M:N sein. Es ist auch die Bezugnahme auf gleiche Entitätstypen möglich, z.B.: 35 vgl. 1.2.2.1 56 Algorithmen und Datenstrukturen Person 1 1 Heirat Abb.: 1.3-15: Bezugnahme auf den gleiche Entitätstyp „Person“ Zur Verwaltung großer Datenbestände nutzen Datenbanken - die Speicherung von Daten in Tabellenform mit effizienten Zugriffsalgorithmen nach wahlfreien Kriterien und SQL als Datenzugriffssprache Datenbanken zeigen den praktischen Einsatz vieler vorgestellten Methoden, Algorithmen und Datenstrukturen, z.B. die Speicherung in Tabellen hinsichtlich - - der Dateiorganisationsform o sortiert nach Schlüssel o B-Baum nach Schlüssel o Hash-Tabelle nach Schlüssel Zugriffsunterstützung nach Index o Primärindexe verweisen auf Hauptdatei o B –Bäume für Nichtschlüsselattribute zur Bescheunigung des Zugriffs (Sekundärindex) Die folgende Darstellung einer Datenbank in einem ER-Diagramm Abt_ID Bezeichnung Job_ID Titel Abteilung Gehalt Job Abt-Ang Job-Ang Qualifikation Angestellte Ang_ID Name GebJahr Abb.: ER-Diagramm zur Datenbank Personalverwaltung führt zum folgenden Schemaentwurf einer relationalen Datenbank - Abteilung(Abt_ID,Bezeichnung) - Angestellte(Ang_ID,Name,Gebjahr,Abt_ID,Job_ID) - Job(Job_ID,Titel,Gehalt) - Qualifikation(Ang_ID,Job_ID) und resultiert in folgender relationalen Datenbank für das Personalwesen: 57 Algorithmen und Datenstrukturen ABTEILUNG ABT_ID KO OD PA RZ VT BEZEICHNUNG Konstruktion Organisation und Datenverarbeitung Personalabteilung Rechenzentrum Vertrieb ANG_ID A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 NAME Fritz Tom Werner Gerd Emil Uwe Eva Rita Ute Willi Erna Anton Josef Maria ANGESTELLTE GEBJAHR 2.1.1950 2.3.1951 23.4.1948 3.11.1950 2.3.1960 3.4.1952 17.11.1955 02.12.1957 08.09.1962 7.7.1956 13.10.1966 5.7.1948 2.8.1952 17.09.1964 ABT_ID OD KO OD VT PA RZ KO KO OD KO OD OD KO PA JOB_ID SY IN PR KA PR OP TA TA SY IN KA SY SY KA JOB JOB_ID KA TA SY PR OP TITEL Kaufm. Angestellter Techn. Angestellter Systemplaner Programmierer Operateur GEHALT 3000,00 DM 3000,00 DM 6000,00 DM 5000,00 DM 3500,00 DM QUALIFIKATION ANG_ID A1 A1 A1 A2 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 JOB_ID SY PR OP IN SY PR KA PR OP TA IN SY IN KA SY IN KA Abb. 1.3-17: Tabellen zur relationalen Datenbank 58 Algorithmen und Datenstrukturen Die relationale Datenbank besteht, wie die vorliegende Darstellung zeigt aus einer Datenstruktur, die Dateien (Tabellen) vernetzt. Die Verbindung besorgen Referenzen (Fremdschlüssel). 1.3.5 Definitionsmethoden für Datenstrukturen 1.3.5.1 Der abstrakte Datentyp Anforderungen an die Definition eines Datentyps 36 - Die Spezifikation eines Datentyps sollte unabhängig von seiner Implementierung sein. Daurch kann die Spezifikation für unterschiedliche Implementierungen verwendet werden. Reduzierung der von außen sichtbaren (zugänglichen) Aspekte auf der Schnittstelle des Datentyps. Dadurch kann die Implementierung später verwendet werden, ohne dass Programmteile, die den Datentyp benutzen, angepasst werden. Aus diesen Anforderungen ergeben sich zwei Prinzipien: - Kapselung (ecucapsultaion): Alle Zugriffe gehen immer nur über die Schnittstelle des Datentyps Geheimnisprinzip (programming by contract). Die interne Realisierung des Datentyps bleibt dem Benutzer verborgen Ein Datentyp, dem nur Spezifikation und Eigenschaften (bspw. in Form von Regeln oder Gesetzmäßigkeiten bekannt sind, heißt abstrakt. Man abstrahiert hier von der konkreten Implementierung. Ein abstrakter Datentyp wird als ADT bezeichnet. Die Definition einer Datenstruktur ist bestimmt durch Daten (Datenfelder, Aufbau, Wertebereiche) und die für die Daten gültigen Rechenvorschriften (Algorithmen, Operationen). Datenfelder und Algorithmen bilden einen Typ, den abstrakten Datentyp (ADT). Eine Spezifikation eines ADT besteht aus: - Angabe der Signatur. Sie legt die Namen der Typen sowie die Funktionstypen fest und bildet die Schnittstelle eines ADT. Mengen und Funktionen, die zur Signatur passen, heißen Algebren Gleichungen dienen als Axiome zur Einschränkung möglicher Algebren als Modell. Zusätzlich erfolgt evtl. ein Import anderer Spezifikationen. Daten und Algorithmen als Einheit zu sehen, war bereits schon vor 1980 bekannt. Da damals noch keine allgemein einsetzbare Implementierung vorlag, hat man Methoden zur Deklaration von ADT 37 bereitgestellt. Damit sollte dem Programmierer wenigstens durch die Spezifikation die Einheit von Daten und zugehörigen Operationen vermittelt werden. 36 37 vgl. 1.3.1 vgl. Guttag, John: "Abstract Data Types and the Development of Data Structures", CACM, June 1977 59 Algorithmen und Datenstrukturen 1.3.5.2 Die axiomatische Methode Die axiomatische Methode beschreibt abstrakte (Daten-)Typen über die Angabe einer Menge von Operationen und deren Eigenschaften, die in der Form von Axiomen präzisiert werden. Problematisch ist jedoch: Die Axiomenmenge ist so anzugeben, daß Widerspruchsfreiheit, Vollständigkeit und möglichst Eindeutigkeit erzielt wird. Algebraische Spezifikation Eine spezielle axiomatische Methode ist die algebraische Spezifikation von Datenstrukturen. Sie soll hier stellvertretend für axiomatische Definitionsmethoden an einem Beispiel vorgestellt werden. 1. Bsp.: Die algebraische Spezifikation des (ADT) Schlange Konventionell würde die Datenstruktur Schlange so definiert werden: Eine Schlange ist ein lineares Feld, bei dem nur am Anfang Knoten entfernt und nur am Ende Knoten hinzugefügt werden können. Die Definition ist ungenau. Operationen sollten mathematisch exakt als Funktionen und Beziehungen der Operationen als Gleichungen angegeben sein. Erst dann ist die Prüfung auf Konsistenz und der Nachweis der korrekten Implementierung möglich. Die algebraische Spezifikation bestimmt den ADT Schlange deshalb folgendermaßen: ADT Schlange Typen Schlange<T>, boolean Funktionen (Protokoll) NeueSchlange FuegeHinzu : Vorn : Entferne : Leer : → Schlange<T> T,Schlange<T> → Schlange<T> → T Schlange<T> Schlange<T> → Schlange<T> → boolean Schlange<T> Axiome Für alle t : T bzw. s : Schlange<T> gilt: 1. 2. 3. 4. 5. 6. Leer(NeueSchlange) = wahr Leer(FuegeHinzu(t,s)) = falsch Vorn(NeueSchlange) = Fehler Vorn(FuegeHinzu(t,s)) = Wenn Leer(s), dann t; andernfalls Vorn(s) Entferne(NeueSchlange) = Fehler Entferne(FuegeHinzu(t,s)) = Wenn Leer(s), dann NeueSchlange; andernfalls FuegeHinzu(t,Entferne(s)) Der Abschnitt Typen zeigt die Datentypen der Spezifikation. Der 1. Typ ist der spezifizierte ADT. Von anderen Typen wird angenommen, daß sie an anderer Stelle definiert sind. Der Typ „Schlange<T>“ wird als generischer ADT bezeichnet, da er "übliche Schlangeneigenschaften" bereitstellt. Eigentliche Schlangentypen erhält man durch die Vereinbarung eines Exemplars des ADT, z.B.: Schlange<integer> Der Abschnitt Funktionen zeigt die auf Exemplare des Typs anwendbaren Funktionen: f : D1 , D2 ,...., Dn → D . Einer der Datentypen D1 , D2 ,...., Dn oder D muß der spezifizierte ADT sein. 60 Algorithmen und Datenstrukturen Die Funktionen können eingeteilt werden in: - Konstruktoren (constructor functions) (Der ADT erscheint nur auf der rechten Seite des Pfeils.) Sie liefern neue Elemente (Instanzen) des ADT. - Zugriffsfunktionen (accessor functions) (Der ADT erscheint nur auf der linken Seite des Pfeils.) Sie liefern Eigenschaften von existierenden Elementen des Typs (vgl. Die Funktion: Leer) - Umsetzungsfunktionen (transformer functions) (Der ADT erscheint links und rechts vom Pfeil.) Sie bilden neue Elemente des ADT aus bestehenden Elementen und (möglicherweise) anderen Argumenten (vgl. FuegeHinzu, Entferne). Der Abschnitt Axiome beschreibt die dynamischen Eigenschaften des ADT. 2. Bsp.: Die „algebraische Spezifikation“ des ADT Stapel ADT Stapel<T>, integer, boolean 1. Funktionen (Operationen, Protokoll) NeuerStapel PUSH POP Top Stapeltiefe Leer : : : : : T,Stapel<T> Stapel<T> Stapel<T> Stapel<T> Stapel<T> → → → → → → Stapel<T> Stapel<T> Stapel<T> T integer boolean 2. Axiome Für alle t:T und s:Stapel<T> gilt: (POP(PUSH(t,s)) = s Top(PUSH(t,s)) = t Stapeltiefe(NeuerStapel) = 0 Stapeltiefe(PUSH(i,s)) = Stapeltiefe + 1 Leer(NeuerStapel) = wahr ¬ Leer(PUSH(t,s) = wahr 3. Restriktionen (conditional axioms) Wenn Stapeltiefe(s) = 0, dann führt POP(s) auf einen Fehler Wenn Stapeltiefe(s) = 0, dann ist Top(s) undefiniert Wenn Leer(s) = wahr, dann ist Stapeltiefe(s) Null. Wenn Stapeltiefe(s) = 0, dann ist Leer(s) wahr. Für viele Programmierer ist eine solche Spezifikationsmethode zu abstrakt. Die Angabe von Axiomen, die widerspruchsfrei und vollständig ist, ist nicht möglich bzw. nicht nachvollziehbar. 3. Bsp.: Die algebraische Spezifikation für einen binären Baum ADT Binaerbaum<T>, boolean 1. Funktionen (Operationen, Protokoll) NeuerBinaerbaum -> Binaerbaum<T> bin : Binaerbaum<T>, T, Binaerbaum<T> → Binaerbaum<T> → Binaerbaum<T> links : Binaerbaum<T> → Binaerbaum<T> rechts : Binaerbaum<T> 61 Algorithmen und Datenstrukturen wert : Binaerbaum<T> istLeer : Binaerbaum<T> -> T → boolea 2. Axiome Für alle t:T und x:Binaerbaum<T>, y:Binaerbaum<T> gilt: links(bin(x,t,y)) = x rechts(bin(x,t,y)) = y wert(bin(x,t,y)) = t istLeer(NeuerBinaerbaum) = true istLeer(bin(x,t,y)) = false Der direkte Weg zur Deklaration von ADT im Rahmen der objektorientierten Programmierung ist noch nicht weit verbreitet. Der konventionelle Programmierstil, Daten und Algorithmen getrennt zu behandeln, bevorzugt den konstruktiven Aufbau der Daten aus elementaren Datentypen. Realisierung von abstrakten Datentypen Die folgenden Elemente müssen im Programm abgebildet werden: - Name des ADT wird üblicherweise der Klassenname Importierte ADTs werden sowohl zur Definition mit dem entsprechenden importierten Typ, als auch zu Importanweisungen innerhalb des Programms Objekterzeugende Operatoren: sog. Konstruktoren werden in den (meist speziellen) Klassenmethoden abgebildet, die ein neues Objekt des gewünschten Typ zurückliefern Lesende Opeartoren: sog. Selektoren werden zu Methoden, die auf die Attribute nur lesend zugreifen. Scheibende Operatoren: sog. Manipulatoten werden zu Methoden, die den Zustand des Objekts verändern Axiome müssen sichergestellt sein. 1.3.5.3 Die konstruktive Methode Die Basis bilden hier die Datentypen. Jedem Objekt ist eine Typvereinbarung in der folgenden Form zugeordnet: X : T; X ... Bezeichner (Identifizierer) für ein Objekt T ... Bezeichner (Identifizierer) für einen Datentyp Einem Datentyp sind folgende Eigenschaften zugeordnet: 1. Ein Datentyp bestimmt die Wertmenge, zu der eine Konstante gehört oder die durch eine Variable oder durch einen Ausdruck angenommen werden kann oder die durch einen Operator oder durch eine Funktion berechnet werden kann. 2. Jeder Operator oder jede Funktion erwartet Argumente eines bestimmten Typs und liefert Resultate eines bestimmten Typs. Bei der konstruktiven Methode erfolgt die Definition von Datenstrukturen mit Hilfe bereits eingeführter Datentypen. Die niedrigste Stufe bilden die einfachen Datentypen. Basis-Datentypen werden in den meisten Programmiersprachen zur Verfügung gestellt und sind eng mit dem physikalischen Wertevorrat einer DVAnlage verknüpft (Standard-Typen). Sie sind die „Atome“ auf der niedrigsten Betrachtungsebene. Neue "höherwertige" Datentypen werden aus bereits definierten „niederstufigen“ Datentypen definiert. 62 Algorithmen und Datenstrukturen 1.3.5.4 Die objektorientierte Modellierung abstrakter Datentypen Die Spezifikation abstrakter Datentypen Im Mittelpunkt dieser Methode steht die Definition von Struktur und Wertebereich der Daten bzw. eine Sammlung von Operationen mit Zugriff auf die Daten. Jede Aufgabe aus der Datenverarbeitung läßt sich auf ein solches Schema (Datenabstraktion) zurückführen. Zur Beschreibung des ADT dient das folgende Format: ADT Name Daten Beschreibung der Datenstruktur Operationen Konstruktor Intialisierungswerte: Daten zur Initialisierung des Objekts Verarbeitung: Initialisierung des Objekts Operation1 Eingabe: Daten der Anwendung dieser Methode Vorbedingung: Notwendiger Zustand des Systems vor Ausführung einer Operation Verarbeitung: Aktionen, die an den Daten ausgeführt werden Ausgabe: Daten (Rückgabewerte) an die Anwendung dieser Methode Nachbedingung: Zustand des Systems nach Ausführung der Operation Operation2 ......... Operationn ......... Bsp.: Anwendung dieser Vorlage zur Beschreibung des ADT Stapel ADT Stapel Daten Eine Liste von Datenelementen mit einer Position „top“, sie auf den Anfang des Stapels verweist. Operationen Konstruktor: Initialisierungswerte: keine Verarbeitung: Initialisiere „top“. Push Eingabe: Ein Datenelement zur Aufnahme in den Stapel Vorbedingung: keine Verarbeitung: Speichere das Datenelement am Anfang („top“) des Stapel Ausgabe: keine Nachbedingung: Der Stapel hat ein neues Datenelement an der Spitze („top“). Pop Eingabe: keine Vorbedingung: Der Stapel ist nicht leer Verarbeitung: Das Element an der Spitze („top“) wird entfernt. Ausgabe: keine Peek bzw. Top Eingabe: keine Vorbedingung: Stapel ist nicht leer Verarbeitung: Bestimme den Wert des Datenelements an der Spitze („top“ des Stapel. Ausgabe: Rückgabe des Datenwerts, der an der Spitze („top“) des Stapel steht. 63 Algorithmen und Datenstrukturen Nachbedingung: Der Stapel bleibt unverändert. Leer Eingabe: keine Vorbedingung: keine Verarbeitung: Prüfe, ob der Stapel leer ist. Ausgabe: Gib TRUE zurueck, falls der Stapel leer ist; andernfalls FALSE. Nachbedingung: keine bereinigeStapel Eingabe: keine Vorbedingung: keine Verarbeitung: Löscht alle Elemente im Stapel und setzt die Spitze („top“) des Stapels zurück. Ausgabe: keine Klassendiagramme der Unified Modelling Language Visualisierung und Spezifizierung objektorientierter Softwaresysteme erfolgt mit der Unified Modelling Language (UML). Zur Beschreibung abstrakter Dytentypen dient das wichtigste Diagramm der UML: Das Klassendiagramm. Das Klassendiagramm beschreibt die statische Struktur der Objekte in einem System sowie ihre Beziehungen untereinander. Die Klasse ist das zentrale Element. Klassen werden durch Rechtecke dargestellt, die entweder den Namen der Klasse tragen oder zusätzlich auch Attribute und Operationen. Klassenname, Attribute, Operationen (Methoden) sind jeweils durch eine horizontale Linie getrennt. Klassennamen beginnen mit Großbuchstaben und sind Substantive im Singular. Ein strenge visuelle Unterscheidung zwischen Klassen und Objekten entfällt in der UML. Objekte werden von den Klassen dadurch unterschieden, daß ihre Bezeichnung unterstrichen ist. Haufig wird auch dem Bezeichner eines Objekts ein Doppelpunkt vorangestellt.. Auch können Klassen und Objekte zusammen im Klassendiagramm auftreten. Klasse Objekt Wenn man die Objekt-Klassen-Beziehung (Exemplarbeziehung, Instanzbeziehung) darstellen möchte, wird zwischen einem Objekt und seiner Klasse ein gestrichelter Pfeil in Richtung Klasse gezeichnet: Klasse Objekt Die Definition einer Klasse umfaßt die „bedeutsamen“ Eigenschaften. Das sind: - Attribute d.h.: die Struktur der Objekte: ihre Bestandteile und die in ihnen enthaltenen Informationen und Daten.. Abhängig von der Detaillierung im Diagramm kann die Notation für ein Attribut den Attributnamen, den Typ und den voreingestellten Wert zeigen: Sichtbarkeit Name: Typ = voreingestellter Wert - Operationen d.h.: das Verhalten der Objekte. Manchmal wird auch von Services oder Methoden gesprochen. Das Verhalten eines Objekts wird beschrieben durch die möglichen Nachrichten, die es verstehen kann. Zu jeder Nachricht benötigt das Objekt entsprechende Operationen. Die UML-Syntax für Operationen ist: Sichtbarkeit Name (Parameterliste) : Rückgabetypausdruck (Eigenschaften) 64 Algorithmen und Datenstrukturen Sichtbarkeit ist + (öffentlich), # (geschützt) oder – (privat) Name ist eine Zeichenkette Parameterliste enthält optional Argumente, deren Syntax dieselbe wie für Attribute ist Rückgabetypausdruck ist eine optionale, sprachabhängige Spezifikation Eigenschaften zeigt Eigenschaftswerte (über String) an, die für die Operation Anwendung finden - Zusicherungen Die Bedingungen, Voraussetzungen und Regeln, die die Objekte erfüllen müssen, werden Zusicherungen genannt. UML definiert keine strikte Syntax für die Beschreibung von Bedingungen. Sie müssen nur in geschweifte Klammern ({}) gesetzt werden. Idealerweise sollten Regeln als Zusicherungen (engl. assertions) in der Programmiersprache implementiert werden können. Attribute werden mindestens mit ihrem Namen aufgeführt und können zusätzliche Angaben zu ihrem Typ (d.h. ihrer Klasse), einen Initialwert und evtl. Eigenschaftswerte und Zusicherungen enthalten. Attribute bilden den Datenbestand einer Klasse. Operationen (Methoden) werden mindestens mit ihrem Namen, zusätzlich durch ihre möglichen Parameter, deren Klasse und Initialwerte sowie evtl. Eigenschaftswerte und Zusicherungen notiert. Methoden sind die aus anderen Sprachen bekannten Funktionen. Klassenname attribut:Typ=initialerWert operation(argumentenliste):rückgabetyp Abb.: Bsp.: Die Klasse Object aus dem Paket java.lang Object +equals(obj :Object) #finalize() +toString() +getClass() #clone() +wait() +notify() ........ Sämtliche Java-Klassen bilden eine Hierarchie mit java.lang.Object als gemeinsame Basisklasse. Assoziationen repräsentieren Beziehungen zwischen Instanzen von Klassen. Mögliche Assoziationen sind: - einfache (benannte) Assoziationen 65 Algorithmen und Datenstrukturen - Assoziation mit angefügten Attributen oder Klassen - Qualifzierte Assoziationen - Aggregationen - Assoziationen zwischen drei oder mehr Elementen - Navigationsassoziationen - Vererbung Attribute werden von Assoziationen unterschieden: Assoziation: Beschreibt Beziehungen, bei denen beteiligte Klassen und Objekte von anderen Klassen und Objekten benutzt werden können. Attribut: Beschreibt einen privaten Bestandteil einer Klasse oder eines Objekts, welcher von außen nicht sichtbar bzw. modifizierbar ist. Grafisch wird eine Assoziation als durchgezogene Line wiedergegeben, die gerichtet sein kann, manchmal eine Beschriftung besitzt und oft noch weitere Details wie z.B. Muliplizität (Kardinalität) oder Rollenanmen enthält, z.B.: Arbeitet für 0..1 Arbeitgeber Arbeitnehmer Eine Assoziation kann einen Namen zur Beschreibung der Natur der Beziehung („Arbeitet für“) besitzen. Damit die Bedeutung unzweideutig ist, kann man dem Namen eine Richtung zuweisen: Ein Dreieck zeigt in die Richtung, in der der Name gelesen werden soll. Rollen („Arbeitgeber, Arbeitnehmer) sind Namen für Klassen in einer Relation. Eine Rolle ist die Seite, die die Klasse an einem Ende der Assoziation der Klasse am anderen Ende der Assoziation zukehrt. Die Navigierbarkeit kann durch einen Pfeil in Richtung einer Rolle angezeigt werden. Rolle1 Rolle2 K1 K2 1 0..* Abb.: Binäre Relation R = C1 x C2 Rolle1 K1 K2 Rollen ... Kn Abb.: n-äre Relation K1 x K2 x ... x Kn In vielen Situationen ist es wichtig anzugeben, wie viele Objekte in der Instanz einer Assoziation miteinander zusammenhänen können. Die Frage „Wie viele?“ bezeichnet man als Multiplizität der Rolle einer Assoziation. Gibt man an einem Ende der Assoziation eine Multiplizität an, dann spezifiziert man dadurch: Für jedes Objekt am entgegengesetzten Ende der Assoziation muß die angegebene Anzahl von Objekten vorhanden sein. 66 Algorithmen und Datenstrukturen Ein A ist immer mit Ein A ist immer mit Ein A ist mit einem B assoziiert einem oder mehre- keinem oder ren B assoziiert einem B assoziiert Ein A ist mit keinem, einem oder mehreren B assoziiert Unified A 1 B A 1..* B A 0..1 B A * B 1:1 1..* 1:1..n 0..* 2..6 0..* * 17 4 n m 0..n:2..6 0..n:0..n 17:4 ? Abb.: Kardinalitäten für Beziehungen Pfeile in Klassendiagrammen zeigen Navigierbarkeit an. Wenn die Navigierbarkeit nur in einer Richtung existiert, nennt man die Assoziation eine gerichtete Assoziation (uni-directional association). Eine ungerichtete (bidirektionale) Assoziation enthält Navigierbarkeiten in beiden Richtungen. In UML bedeuten Assoziationen ohne Pfeile, daß die Navigierbarbeit unbekannt oder die Assoziation ungerichtet ist. Ungerichtete Assoziationen enthalten eine zusätzliche Bedingung: Die zu dieser Assoziation zugehörigen zwei Rollen sind zueinander invers. Abhängigkeit (dependency): Manchmal nutzt eine Klasse eine andere. Die UMLNotation ist dafür oft eine gestrichelte Linie mit einem Pfeil, z.B.: Applet WillkommenApplet paint() Graphics Abb. : WillkommenApplet nutzt die Klasse Graphics über paint() Reflexive Assoziation: Manchmal ist auch eine Klasse mit sich selbst assoziiert. Das kann bspw. der fall sein, wenn eine Klasse Objekte hat, die mehrere Rollen spielen, z.B.: 67 Algorithmen und Datenstrukturen Fahrzeuginsasse 1 fahrer fährt 0..4 beifahrer Ein Fahrzeuginsasse kann entweder ein Fahrer oder ein Beifahrer sein. In der Rolle des Fahrers fährt ein Fahrzeuginsasse null oder mehr Fahrzeuginsassen, die die Rolle von Beifahrern spielen. Abb.: Bei einer reflexiven Assoziation zieht man eine Linie von der Klasse aus zu dieser zurück. Man kann die Rollen sowie die Namen, die Richtung und die Multiplizität der Assoziation angeben. Eine Aggregation ist eine Sonderform der Assoziation. Sie repräsentiert eine (strukturelle) Ganzes/Teil-Beziehung. Zusätzlich zu einfacher Aggregation bietet UML eine stärkere Art der Aggregation, die Komposition genannt wird. Bei der Komposition darf ein Teil-Objekt nur zu genau einem Ganzen gehören. Teil Ganzes Existenzabhängiges Teil Abb.: Aggregation und Komposition Eine Aggregation wird durch eine Raute dargestellt. Die Komposition wird durch eine ausgefüllte Raute dargestellt und beschreibt ein „physikalisches Enthaltensein“. Die Vererbung (Spezialisierung bzw. Generalisierung) stellt eine Verallgemeinerung von Eigenschaften dar. Eine Generalisierung (generalization) ist eine Beziehung zwischen dem Allgemeinen und dem Speziellen, in der Objekte des speziellen Typs (der Subklasse) durch Elemente des allgemeinen Typs (der Oberklassse) ersetzt werden können. Grafisch wird eine Generalisierung als durchgezogene Linle mit einer unausgefüllten, auf die Oberklasse zeigenden Pfeilspitze wiedergegeben, z.B.: Supertyp Subtyp 1 Subtyp 2 68 Algorithmen und Datenstrukturen Bsp.: Vererbungshierarchie und wichtige Methoden der Klasse Applet Panel Applet +init() +start() +paint(g:Graphics) {geerbt} +update(g:Graphics) {geerbt} +repaint() +stop() +destroy() +getParameter(name:String); +getParameterInfo() +getAppletInfo() Abb.: Schnittstellen und abstrakte Klassen: Eine Schnittstelle (Interface) ist eine Ansammlung von Operationen, die eine Klasse ausführt. Programmiersprachen (z.. B. Java) benutzen ein einzelnes Konstrukt, die Klasse, die sowohl Schnittstelle als auch deren Implementierung enthält. Bei der Bildung einer Unterklasse wird beides vererbt. Eine reine Schnittstelle (wie bspw. in Java) ist eine Klasse ohne Implementierung und besitzt daher nur Operationsdeklarationen. Schnittstellen werden oft mit Hilfe abstrakter Klassen deklariert. Bei abstrakten Klassen oder Methoden wird der Name des abstrakten Gegenstands in der UML kursiv geschrieben. Ebenso kann man die Bedingung {abstract} benutzen. <<interface>> InputStream DataInput OrderReader {abstract} Abhängigkeit Generalisierung Verfeinerung DataInputStream Irgendeine Klasse, z.B. „OrderReader“ benötigt die DataInput-Funktionalität. Die Klasse DataInputStream implementiert DataInput und InputStream. Die Verbindung zwischen DataInputStream und DataInput ist eine „Verfeinerung (refinement)“. Eine Verfeinerung ist in UML ein allgemeiner Begriff zur Anzeige eines höheren Detaillierungsniveaus. Die Objektbeziehung zwischen OrderReader und DataInput ist eine Abhängigkeit. Sie zeigt, daß „OrderReader“ die Schnittstelle „DataInput für einige Zwecke benutzt. Abb.: Schnittstellen und abstrakte Klassen: Ein Beispiel aus Java Abstrakte Klassen und Schnittstellen ermöglichen die Definition einer Schnittstelle und das Verschieben ihrer Implementierung auf später. Jedoch kann die abstrakte 69 Algorithmen und Datenstrukturen Klasse schon die Implementierung einiger Methoden enthalten, während die Schnittstelle die Verschiebung der Definition aller Methoden erzwingt. Eine Schnittstelle modelliert man in Form einer gestrichelten Linie mit einem großen, unausgefüllten Dreieck, das neben der Schnittstelle steht und auf diese zeigt. Eine andere verkürzte Darstellung einer Klasse und einer Schnittstelle besteht aus einem (kleinen Kreis), der mit der Klasse durch eine Linie verbunden ist, z.B.: Object Component ImageObserver Container Panel Applet Abb.: Vererbungshierarchie von Applet 70 Algorithmen und Datenstrukturen 1.3.5.6 Die Implementierung abstrakter Datentypen in Java 1.3.5.6.1 Klassen und Schnittstellen (Referenzdatentypen) 1. Klassen Top-level Klassen: Die Verwendung von Klassen ist in Java, im Gegensatz zu C++, zwingend. Jede Klasse bildet einen abgeschlossenen Sichtbarkeitsbereich für die darin definierten Attribute und Methoden. Eine Java-Klasse besteht aus der in der folgenden Abbildung dargestellten Bestandteilen: public abstract final class KlassenName extends KlassenName implements InterfaceListe { // Attribute type attributName; // Konstruktor public KlassenName() { // ... } // Methoden public xyz( ... ) { ... } ...... } Abb.: Bestandteile von Java-Klassen Am Anfang steht die Klassendeklaration. Sie benennt die Klasse eindeutig, und legt die allgemeinen Merkmale der Klasse fest: public abstract final class KlassenName extends KlassenName implements InterfaceListe { // Klassenkörper } Die Klasse ist allgemein sichtbar. Vorgabegemäß kann eine Klasse nur von Klassen desselben Packages genutzt werden. Durch das Schlüsselwort public wird sie auch außerhalb des umgebenden Packages sichtbar und zugreifbar. Die namensgebende Klasse einer Java-Quellcode-Datei, due auch die main()-Methode enthalten kann, muß zwingend als public erklärt sein. Abstrakte Klassen dienen zur Strukturierung des Entwurfs, um gemeinsame Merkmale verschiedener Klassen zentralisiert ausdrücken zu können. Von einer abstrakten Klasse kann nicht geerbt werden. So können Vererbungsgäste ausgeschlossen werden.An dieser Stelle kann keine Weiterentwicklung erfolgen. Das Schlüsselwort verhindert einen entsprechende Versuch zum Übersetzungszeitpunkt. Name der Klasse Die Klasse erbt von der Klasse KlassenName. In Java ist nur einfache Vererbung zugelassen, daher kann an dieser Stelle auch maximal nur eine Superklasse spezifiziert werden. Die Klasse implementiert die in InterfaceLIste aufgeführten Schnittstellen. Die Schnittstellennamen werden in der Liste durch Kommata getrennt. Ausprogrammierter Klassenrumpf 71 Algorithmen und Datenstrukturen Objekterzeugung: Die Erzeugung konkreter Ausprägungen (auch Instanzen oder Objekte) einer Klasse geschieht üblicherweise durch den new-Operator: Type variable = new Type(parameter) Innere Klassen Lokale Klassen: Klassen können innerhalb von Klassen definiert werden, z.B. class Aussen { ... class Innen { ... } ... } - Objekte der inneren Klassen können auf private Daten des erstellenden Objekts zugreifen Innere Klassen unterliegen der Sichtbarkeit der umgebenden Klasse, d.h. sie sind vor Zugriffen anderer Klassen geschützt. Für innere Klassen wird eine eigenständige class-Datei mit der Namenskonvention UmgebendeKlasse$innereKlasse erzeugt. Anonyme Klassen: Die eingebettete Klasse kann anonym definiert sein, z.B. new Basisklasse(parameter) { // Datenelemente und Methoden der inneren Klasse }; Java setzt für anonyme Klassen den Namen aus dem Namen der umgebenden Klasse, dem Zeichen $ und einer fortlaufenden Nummer zusammen. Wrapper-Klassen Korrespondierend zu jedem primitiven Datentyp in Java gibt es einen Wrapper-Typ. Sie kapselt den zugrundeliegenden Primitivtyp in eine eigene Klasse und stellt einige Servicemethoden bereit. Primitivtyp boolean byte short int long float double void 38 Wrapper-Typ Boolean Byte Short Integer Long Float Double Void 39 Alle Wrapper-Typen bieten bestimmte Service-Methoden an. - 38 39 Alle Wrapper-Typen sind final deklariert und können nicht weiter spezialisiert werden. kann nur als Rückgabetyp von Operationen spezifiziert werden kann nicht instanziiert werden 72 Algorithmen und Datenstrukturen - - - - ...Value(), z.B. booleanValue(), byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue(). All diese Methoden geben den intern gekapselten Wert unverändert zurück. Darüber hinaus existieren Methoden zur Ausgabe eines numerischen Wrapper-Typs in einen beliebigen numerischen Primitivtyp 40. Konstruktoren erlauben die Erzeugung eines Wrappertyps aus einem Ausdruck vom Typ des gekapselten Typs oder aus einem String. compareTo() vergleicht den gekapselten zweier Wrappertyp-Objekte. parse...() Methoden, z.B. parseByte(String s), parseByte(String s, int radix), parseInt(String s), parseInt(String s, int radix), erzeugen aus Zeichenketten den jeweiligen Primitivtyp. valueOf(). Für alle Wrapper-Typen integraler Primitivtypen (byte, char, long, int, short) ist mit der valueOf()-Methode eine (Factory-) Methode zur Erzeugung eines neuen WrapperObjekts aus einer Zeichenkette definiert. die üblichen arithmetischen Operationen stehen zur Verknüpfung von Wrapperobjekten nicht zur Verfügung (kein Operator overloading). Boxing / Unboxing: Mit Java 1.5 eingeführte dynamische Umwandlung zwischen primitiven Werten und den zugehörigen Wrapper-Klassen. Boxing: automatische Wrapper-Erzeugung Unboxing: Wandlung eines objektgekapselten Werts in einen Primitivwert. Die automatische Typumwandlung wird mit Java 1.5 ausschließlich für Übergabeparameter angeboten. Bsp. 41: public class BUBTest1 { public static void main(String[] args) { BUBTest1 obj = new BUBTest1(); obj.boxIt( new Integer(42) ); obj.boxIt( 42 ); //dynamic boxing obj.unBoxIt( 42 ); //nothing new obj.unBoxIt( new Integer(42) ); //dynamic unboxing } //main() public void boxIt(Integer i) { System.out.println("value="+i); } //boxIt public void unBoxIt(int i) { System.out.println("value="+i); } //unBoxIt } //class BUBTest1 Der Boxingvorgang kann außer für Wrapper-Typen auch für Objekte der Klasse Object durchgeführt werden. Da diese als Superklasse aller Wrapper-Typen angelegt ist, ist diese Typkonversion typkonform. Bsp. 42: public class BUBTest2 { public static void main(String[] args) { BUBTest2 obj = new BUBTest2(); obj.boxIt( new Integer(42) ); obj.boxIt( 42 ); //dynamic boxing 40 ersetzen die explizite Typumwandlung pr12361 42 pr12361 41 73 Algorithmen und Datenstrukturen } //main() public void boxIt(Object i) { System.out.println("value=" + i); } //boxIt } //class BUBTest2 Die umgekehrte Richtung, d.h. die Verwendung einer Ausprägung von Object an einer Stelle an der eine konkrete Zahl (z.B. int-Zahl) erwartet wird ist – nach Maßgabe der nicht typsicher möglichen Konversion entgegen der Vererbungsrichtung - nicht möglich. Aufzählungstypen Im einfachsten Anwendungsfall besteht die Definition von Aufzählungstypen aus der durch Kommata voneinander getrennten, vollständigen Aufzählung aller Werte. Bsp. 43: Aufzählungstyp jahreszeiten, der durch die zulässigen Werte winter, fruehling, sommer, herbst festgelegt ist. public class EnumTest1 { enum jahreszeiten { winter, fruehling, sommer, herbst } public static void main(String args[]) { jahreszeiten jz1 = jahreszeiten.winter; if (jz1 == jahreszeiten.winter) System.out.println("Es ist " + jz1); } } Die Verwendung von Aufzählungstypen entspricht der von Primitivtypen. Aus diesem Grund ist keine Anforderung von Speicherplatz durch das new-Schlüsselwort 44 notwendig. Aufzählungstypen lassen sich auch "klassenartig" ausbauen. Diese Erweiterung erlaubt es die Elemente des Aufzählungstypes wahlfrei an selbstdefinierte Eigenschaften zu binden. Konzeptionell werden diese Eigenschaften dabei als Attribute eines Aufzählungstyps aufgefasst, die durch einen vom Programmierer bereitzustellenden Konstruktor zugewiesen werden. Der Konstruktoraufruf erfolgt dabei automatisch durch das Laufzeitsystem zum Definitionszeitpunkt eines Aufzählungstyps für alle konstituierenden Werte. Bsp. 45: public class EnumTest2 { public enum Muenzen { einCent(1), zweiCent(2), fuenfzent(5), zehnCent(10), zwanzigCent(20), fuenfzigCent(50); private int wert; Muenzen(int wert) { this.wert = wert; } 43 pr12361 Der Übersetzer verhindert sogar aktiv die Instanziierung eines Aufzählungstyps über new und bricht mit einer Fehlermeldung ab 45 pr12361 44 74 Algorithmen und Datenstrukturen public int wert() { return wert; } } public static void main(String args[]) { Muenzen m = Muenzen.fuenfzigCent; System.out.println(m.wert()); } } 2. Schnittstellen (Interfaces) Java erlaubt es nicht, dass eine Klasse mehr als eine Superklasse hat. Mehrfachvererbung ist daher in Java nicht ohne Weiters möglich. Eine Klasse kann aber beliebig viele Interfaces implementieren. Java-Schnittstellen umfassen im wesentlichen Operationen, d.h. Methodensignaturen ohne eigene Implementierung. Ein Interface ist ein ReferenzTyp (, ebenso wie eine Klasse) und gibt Signaturen – Namen und Typen von Methoden (und Konstanten) vor. Interface sind reine Spezifikationen: - - ein Interface wird mit dem Schlüsselwort interface deklariert. ein Interface enthält keinerlei Methoden-Implementation. Alle Methoden sind implizit abstrakt, ( auch wenn ohne diesen Modifikator deklariert). Ein Interface kann nur Instanz-Methoden enthalten. Ein Interface ist ohne Sichbarkeitsmodifikator paketsicher. Als einziger Sichtbarkeitsmodifikator darf public angegeben werden. Alle Methoden sind implizit public, auch wenn der Modifikator nicht explizit angegeben ist. Es ist ein Fehler protected oder private in einem Interface zu deklarieren. Ein Interface kann keine Instanz-Felder deklarieren, aber als static oder final deklarierte Konstanten. Da ein Interface nicht instanziiert werden kann, definiert es keinen Konstruktor. Benutzung: Wenn eine Klasse ein Interface implementiert, können Objekte dieser Klasse Variable vom Typ des Interfaces zugewiesen werden. 75 Algorithmen und Datenstrukturen 1.3.5.6.2 Generische Typen Java kannte neben primitiven Datentypen (int, double, etc.) nur Klassen und Interfaces. Ab Version 1.5 unterscheidet Java folgende Typen: - Klassen bzw. Interfaces Typ-Variablen Parametrisierte Typen Generische Array-Typen Die Virtuelle Maschine kennt zur Laufzeit nur Klassen und Interfaces. Die NichtKlassen-Typen sind nur zur Kompilierungszeit bekannt. Typvariable Mit Java 1.5 wird das Typsystem auf generische Typen erweitert. Die Idee für generische Typen ist es eine Klasse zu schreiben, die für verschiedene Typen als Inhalt zu benutzen ist. Die Speicherung beliebiger Objekte kann Java bis zur Version 1.4 nur in Feldern vom Typ Object vollziehen. Allerdings geht damit die typische statische Typinformation verloren. Dynamische Typzusicherung ist in diesem Fall für weitere sinnvolle Nutzung der Objekte unerläßich. Dynamische Typzusicherung kann aber zu Laufzeitfehlern führen: Der folgende generische Binärbaumknoten 46 besitzt einen entscheidenden Nachteil, den eine Übersetzung mit Java 1.5 aufdeckt: // Elementarer Knoten eines binaeren Baums, der nicht ausgeglichen ist class BinaerBaumknoten { // Instanzvariable protected BinaerBaumknoten links; protected BinaerBaumknoten rechts; public Comparable daten; // linker Teilbaum // rechter Teilbaum // Dateninhalt der Knoten // Konstruktor public BinaerBaumknoten(Comparable datenElement) { this(datenElement, null, null ); } public BinaerBaumknoten(Comparable datenElement, BinaerBaumknoten l, BinaerBaumknoten r) { daten = datenElement; links = l; rechts = r; } public void insert (Comparable x) { if (x.compareTo(daten) > 0) // dann rechts { if (rechts == null) rechts = new BinaerBaumknoten(x); else rechts.insert(x); } else // sonst links { if (links == null) links = new BinaerBaumknoten(x); else links.insert(x); 46 pr12362 76 Algorithmen und Datenstrukturen } } public BinaerBaumknoten getLinks() { return links; } public BinaerBaumknoten getRechts() { return rechts; } } Beim Übersetzen mit Java 1.5 erhält man folgende Hinweise: Note: BinaerBaumknoten.java uses unchecked or unsafe operations Note: Recompile with –Xlint:unchecked for details Führt man den letzten Hinweis aus, dann zeigt der Compiler das Problem an: Mit Java 1.5 wird das Typsystem auf generische Typen erweitert. Eine generische Klasse, die statische Typsicherheit garantiert, muß jedes Auftreten des Typs Object (im vorliegenden Fall des Referenzdatentyps Comparable) durch einen Variablennamen ersetzen. Die Variable ist eine Typvariable, die für einen beliebigen Typ steht. Dem Klassennamen wird zusätzlich im Rahmen der Klassendefinition - in spitzen Klammern eingeschlossen - hinzugefügt, dass diese Klasse eine Typvariable benutzt: class C<T> { T t; T m(T t) { T t1 = t; this.t = t1; return this.t; } } Eine generische Klasse ist eine Klasse, die Typvariable benutzt. "T" ist der Name der Typ-Variablen (oder: der formale Typ-Parameter). Sie steht für "irdendeinen" nicht näher spezifizierten Typ. Dieser Typ muß kompatibel mit Object sein. Es kann sich um alles handeln, außer um int, double, etc. Der Compiler generiert aufgrund der vorstehenden Defintion folgende gewöhnliche Klasse C: class C { Oblect t; Object m(Object t) { 77 Algorithmen und Datenstrukturen Object t1 = t; this.t = t1; return this.t; } } Diese vom Compiler definierte Klasse wird als Raw-Type bezeichnet. Zur Laufzeit ( für die VM -) ist C ein generischer Typ, der mit einer Typ-Variablen mit dem Namen T parametrisiert ist. Eine Typ-Variable kann innerhalb der Klasse, für die sie definiert ist, benutzt werden, u.a. zur Definition von Referenzen (Instanzvariablen, lokalen Variablen, Methoden-Parameter) und zur Spezifikation von Rückgabewerten. Typvariablen können auch als parametriserter Typ benutzt werden, z.B.: class A { } ist ein gewöhnlicher Klassentyp. Dann kann die Klasse C folgendermaßen verwendet werden: C<A> c = new C<A> (); A a = c.m (new A ()); C<A> ist ein parametrisierter Typ. A ist der aktuelle Parameter des parametrisierten Typs. C<A> ist eine konkrete Instanz der generischen Klasse C. Für diesen parametrisierten Typ wird vom Compiler aber keine Klasse generiert. Alle Typen C<A>, C>B>, etc. teilen sich also diesselbe Klasse C. Nur dies ist zur Laufzeit bekannt: - Ein C<A> ist niemals kompatibel zu einem C<B>, auch dann nicht, wenn B von A abgeleitet ist Ein C<A> oder ein C<B> sind auch nicht kompatibel zu Object. C<A> und C<B> sind aber kompatibel zum Raw-Type Eine Typ-Variable T ist immer kompatibel zu Object, aber Object ist nicht kompatibel zu T. In der Klasse C können daher über eine T-Referenz alle Methoden aufgerufen werden, die in der Klasse Object definiert sind. Einschränkung der Typvariablen (Typebounds): Bei der Definition der Schablone kann eingeschränkt werden, dass eine Typvariable nur für bestimmte Typen ersetzt werden darf. Es kann vorgeschrieben werden, dass der Typ eine bestimmte konkrete Schnittstelle implementieren muß. Das folgende Programm ersetzt in der angegebenen Lösung zum BinaerBaumknoten den Typ Comparable durch eine Typvariable mit der Angabe, dass diese Variable für alle Typen steht, die Subtypen der Schnittstelle Comparable sind. In der folgenden Lösung 47 wird der Typ Comparable durch eine Typvariable ersetzt. Diese Variable steht für alle Typen, die SubTypen der Schnittstelle Comparable sind. // Elementarer Knoten eines binaeren Baums, der nicht ausgeglichen ist class BinaerBaumknoten<T extends Comparable> { // Instanzvariable protected BinaerBaumknoten<T> links; protected BinaerBaumknoten<T> rechts; public T daten; // Konstruktor public BinaerBaumknoten(T datenElement) 47 vgl. GenericBinaerBaumknoten.java in pr12362 78 // linker Teilbaum // rechter Teilbaum // Dateninhalt der Knoten Algorithmen und Datenstrukturen { this(datenElement, null, null ); } public BinaerBaumknoten(T datenElement, BinaerBaumknoten<T> l, BinaerBaumknoten<T> r) { daten = datenElement; links = l; rechts = r; } public void insert (T x) { if (x.compareTo(daten) > 0) // dann rechts { if (rechts == null) rechts = new BinaerBaumknoten<T>(x); else rechts.insert(x); } else // sonst links { if (links == null) links = new BinaerBaumknoten<T> (x); else links.insert(x); } } public BinaerBaumknoten<T> getLinks() { return links; } public BinaerBaumknoten<T> getRechts() { return rechts; } } Die Lösung ist noch nicht perfekt. Eine abgeleitete Klasse, deren Basisklasse Comparable implementiert, wird nicht akzeptiert, weil die Defintion <T extends Comparable<T>> verlangt, dass das Typargument selbst Comparable ist 48. Vererbung: Eine generische Klasse kann von einer anderen Klasse abgeleitet sein: class B<T> { } class C<T> extends B<T> { } // 2-fache Nutzung: Typvariable in C<T>, aktueller Typ-Parameter in B<T> Wäre die Typ-Variable von B eingeschränkt: class A { } class B<T extends A> { } dann müßte auch die Typ-Variable von C eingeschränkt sein: class C<T extends A> extends B<T> { } Man kann eine nicht generische Klasse von einem parametrisierten Typ ableiten. Eine Ableitungsbeziehung zwischen Typargumenten wird nicht auf generische Typen übertragen. Obwohl bspw. Integer von Number abgeleitet ist, ist BinaerBaumknoten<Integer> nicht kompatibel zu BinaerBaumknoten<Number>. Die folgende Wertzuweisung ist deshalb fehlerhaft: BinaerBaumKnoten<Number> b = new BinaerBaumknoten<Integer>(13) 48 Mit contravarianten Widcardtype kann auch dieses Problem gelöst werden. 79 Algorithmen und Datenstrukturen BinaerBaumknoten<Integer> und BinaerBaumknoten<Number> sind getrennte Typen. Die Eigenschaft wird als Invarianz bezeichnet: Eine Variation der Typargumente in Bezug auf die Vererbungsbeziehungen wirkt sich nicht auf die generischen Typen aus. Generische Array-Typen: Gegeben ist class C<T> { T[] list; } T[] ist ein generischer Typ, der in diesem Fall zur Definition einer Instanzvariablen verwendet wird. Er kann natürlich auch als Typ von lokalen Variablen, MethodenParametern und –Rückgaben dienen. Die Typ-Variable T bezeichnet hier den Typ eines Array, auf welchen über die Variable list zugegriffen werden kann. Der Ausdruck list[i] ist daher vom Typ T. Ein generischer Array-Typ kann auch einen parametrisierten Typ benutzen: C<A>[] list0; Das i-te Element einer solchen Liste wäre dann vom Typ C<A>. Generische Methoden Generische Typen sind nicht an einen objektorientierten Kontext gebunden. In Java verläßt man den objektorientierten Kontext in statischen Methoden. Alle Arten vom Methoden können parametrisiert werden: statische und nicht statische Methoden. Hierzu ist vor die Methodensignatur in spitzen Klammern eine Liste der in den Methoden benutzten Typvariablen anzugeben. Bsp. 49: Generische Methoden der Klasse TestGenericBinaerBaumKnoten public class TestGenericBinaerBaumKnoten { public static void main (String args[]) { BinaerBaumknoten<Integer> baum = null; /* for (int i = 0; i < 20; i++) // 20 Zusfallsstrings speichern { String s = "Zufallszahl " + (int)(Math.random() * 100); if (baum == null) baum = new BinaerBaumknoten(s); } print(baum); // Sortiert wieder ausdrucken */ for (int i = 0; i < 10; i++) { // Erzeuge eine Zahl zwischen 0 und 100 Integer r = new Integer((int)(Math.random()*100)); if (baum == null) baum = new BinaerBaumknoten<Integer>(r); else baum.insert(r); } System.out.println("Inorder-Durchlauf"); print(baum); 49 vgl. pr12362 80 Algorithmen und Datenstrukturen System.out.println(); System.out.println("Baumdarstellung um 90 Grad versetzt"); ausgBinaerBaum(baum,0); // Aufruf parametrisierter Methoden System.out.print("Kleinster Wert: "); System.out.print(findeMin(baum)); System.out.println(); System.out.print("Groesster Wert: "); System.out.print(findeMax(baum)); System.out.println(); } // Generische Methoden public static <T extends Comparable> void print (BinaerBaumknoten<? extends T> baum) // Rekursive Druckfunktion { if (baum == null) return; print(baum.getLinks()); System.out.print(baum.daten + " "); print(baum.getRechts()); } public static <T extends Comparable> void ausgBinaerBaum(BinaerBaumknoten<T> b, int stufe) { if (b != null) { ausgBinaerBaum(b.getRechts(), stufe + 1); for (int i = 0; i < stufe; i++) { System.out.print(" "); } System.out.println(b.daten); ausgBinaerBaum(b.getLinks(), stufe + 1); } } public static <T extends Comparable> T findeMin(BinaerBaumknoten<T> b) { return datenZugriff( findMin(b) ); } public static <T extends Comparable> T findeMax(BinaerBaumknoten<T> b) { return datenZugriff( findMax(b) ); } public static <T extends Comparable> T datenZugriff(BinaerBaumknoten<T> b) { return b == null ? null : b.daten; } public static <T extends Comparable> BinaerBaumknoten<T> findMin(BinaerBaumknoten<T> b) { if (b == null) return null; else if (b.getLinks() == null) return b; return findMin(b.getLinks()); } public static <T extends Comparable> BinaerBaumknoten<T> findMax(BinaerBaumknoten<T> b) { if (b != null) while (b.getRechts() != null) b = b.getRechts(); return b; } } 81 Algorithmen und Datenstrukturen Parametrisierte Methoden werden wie ganz normale Methoden aufgerufen, wie man in der main()-Methode sehen kann. Der konkrete Typ, der den Typparameter ersetzt, muß nicht explizit angegeben werden. Er wird automatisch vom Compiler aus dem Typ des Arguments abgeleitet, das beim Aufruf an die Parametrisierte Methode übergeben wird. Im vorliegenden Bsp. wird BinaerBaumknoten<T> als Argument an die findMin()- bzw. findMax()-Methode übergeben. Generische Schnittstellen Generische Typen erlauben es, den Typ Object in Typsignaturen zu eliminieren. Der Typ Object ist als schlecht anzusehen, denn er ist gleichbedeutend damit, dass keine Information über einen konkreten Typ während der Übersetzungszeit zur Verfügung steht. In herkömmlichen Java ist in APIs von Bibliotheken der Typ Object allgegenwärtig. Sogar in der Klasse Object selbst findet man diesen Typ in Signaturen, z.B. in der Methode equals(). Prinzipiell kann deshalb ein Objekt mit Objekten jedes beliebigen Typs verglichen werden. Häufig will man aber nur gleiche Typen miteinander vergleichen. Generische Typen erlauben es, allgemein eine Gleichheitsmethode zu definieren, in der nur Objekte gleichen Typs miteinander verglichen werden können. Generische Typen erweitern sich ohne Umstände auf Schnittstellen. Die Syntaxregeln sind diesselben wie bei generischen Klassen. Implementierung generischer Interfaces: Gegeben sind: Zwei Klassen A und B und ein generisches Interface I class A {} class B{} interface I<T0 extends A, T1 extends B> { void m0(T0 t); void m1(T1 t); } Das Interface kann dann folgendermaßen implementiert werden: class C implements I<A,B> { public void m0(A a) { } public void m1(B b) { } } 82 Algorithmen und Datenstrukturen 1.3.5.6.3 Wildcard-Typen Grundlagen Wildcards bei Typangaben: Generische Typen können ein unbestimmtes Typargument benennen. Syntaktisch wird dann als Typargument das Wildcardzeichen '?' angegeben, z.B. BinaerBaumknoten<?> b; . Ein derartiger generischer Typ heißt Wildcard-Typ. Alle generischen Typen der gleichen generischen Klasse sind kompatibel zu diesem Wildcard-Typ. Ein Wildcard bezeichnet keinen konkreten Typ, sondern eine Familie von Typen. Folgende Klassen sind bspw. definiert: class A { } class B { } class C<T> { } Folgende Referenzen sind definiert bzw. initialisiert: C<A> ca = new C<A> (); C<B> cb = new C<B> (); Es ist dann nicht möglich, die ca- oder die cb-Variable an eine Variable des Typs C<Object> zuzuweisen, obwohl A und B natürlich von Object abgeleitet sind: C<Object> c = ca; // illegal: incompatible Typs Es ist natürlich möglich, ca und cb an eine Referenz vom raw-type C zuzuweisen: C c = ca; Aber auch folgende Zeilen sind legal C<?> c0 = ca; C<?> c1 = cb; C<?> ist ein parametrisierter Typ, dessen Argument ein Wildcard-Typ ist. Das ? steht hier für irgendeinen Typ. Es gibt drei Arten von Wildcards: ?extends Type, ? super Type und ?. Wildcard-Instanziierungen sehen dann z.B. so aus: List<? extends Number?, List<? super Long> oder List<?>. Upper-Typebound: Das Wildcard ? extends Number bezeichnet bspw. die Menge aller Typen, die von Number direkt oder indirekt abgeleitet sind, d.h. die Familie aller Subtypen von Number (also Long, Integer, usw., inklusive Number). Die WildcardInstanziierung List<extends Number> bezeichnet logischerweise die Familie aller Instanziierungen des parametrisierten Typs List, bei dem ein Typ aus der Familie der Subtypen von Number für den Typparameter eingesetzt wurde (, also List<Long>, List<Integer>, usw., inkl. List<Number>). Zum eingeschränkten Wildcard-Typ BinaerBaumKnoten <? extends Number> sind nur die generischen BinaerBaumknoten-Typen kompatibel, deren Typargument Number ist, z.B.: BinaerBaumknoten<? extends Number> nb; nb = new BinaerBaumknoten<Integer> (23); nb = new BinaerBaumknoten<Object> (new Object()); 83 // OK // Fehler Algorithmen und Datenstrukturen Ein derartiger Typebound wird auch als Upper-Typebound bezeichnet, weil er aus Sicht der Vererbungshierarchie eine Obergrenze für die konkreten Typargumente festlegt. Lower Typebound: Ein Wildcard wie ? super Long bezeichnet die Menge aller Supertypen von Long und das Wildcard ? steht für die Menge aller Typen. Es liegt hier die Umkehrung der Einschränkung vor, wie sie beim Upper-Typebound gegeben ist. Ein solcher Lower-Typebound ist bspw. durch BinaerBaumknoten<? super Number> nb gegeben. Die Typargumente müssen hier Basistypen des LowerTypebound sein. Bsp.: BinaerBaumknoten<? super Number> nb; nb = new BinaerBaumknoten<Object>(new Object()); // OK nb = new BinaerBaumknoten<Integer>(23); // Fehler Der generische Typ BinaerBaumknoten<Object> ist kompatibel zu BinaerBaumknoten<? super Number> , weil Object ein Basistyp von Number ist. Wildcard-Instanziierung eines parametrisierten Types: Eine Wildcard-Instanziierung eines parametrisierten Types kann (verglichen mit einer konkreten Instanziierung) nicht zur Verwendung von Objekten verwendet werden. Man kann zwar eine Variable vom Typ List<? extends Number> deklarieren, aber man kann kein Objekt vom Typ List<? extends Number> erzeugen. Eine Variable vom Typ <List? extends Number> kann aber auf Objekte von kompatiblen Typen (z.B. List<Long> oder List<Integer>) verweisen. Die kompatiblen Typen sind genau die Typen aus der Familie von Typen, die die Wildcard-Instanziierung bezeichnet. Eine Variable vom Typ List<? super Long> kann auf Objekt vom Typ List<Long> oder List<Number> oder List<Comparable> verweisen. Eine Variable vom Typ List<?> kann auf beliebige Instanziierungen von List verweisen. Der Zugriff auf ein Objekt, das über eine Referenzvariable vom Typ WildcardInstanziierung referenziert wird, ist eingeschränkt. Über eine Variable vom Typ List<? extends Number> bspw. dürfen keine Methoden des Typs List aufgerufen werden, die ein Argument von dem Typ nehmen, für das das Wildcard steht: List<? extends Number> list = new LinkedList<Integer>(); list.add(new Integer(25)); Bei einem Wildcard mit super ist der Aufruf von Methoden unmöglich, deren Returntyp von dem Typ ist, für den das Wildcard steht. Für das Wildcard ? gelten beide Einschränkungen. Covarianz generischer Typen. Ein mit extends eingeschränkter Wildcard-Typ wird als covarianter Wildcard-Typ bezeichnet. Die Kompatiblität zwischen einem covarianten Wildcard-Typ und den anderen generischen Typen folgt der gleichen Richtung wie die Verebungsbeziehung zwischen Upper-Typebound und konketem Typargument. Allgemein gilt: C<A> ist kompatibel zu C<? extends B>, wenn A ist kompatibel zu B Contravarianz generischer Typen Die in dem folgenden Beispiel dargestellte Situation 84 Algorithmen und Datenstrukturen BinaerBaumknoten<? super Number> nb; nb = new BinaerBaumknoten<Object>(new Object()); // OK nb = new BinaerBaumknoten<Integer>(23); // Fehler wird als Contravarianz bezeichnet, die entsprechenden Wildcardtypen als contravariante Typen. Contravarianter Typebound. Mit contravarianten Typebounds kann das Problem der generischen Knotenklasse BinaerBaumknoten<? extends Number> gelöst werden, deren Typebound zu streng ist und nur Typargumente zulässt, die selbst das Interface Comparable implementieren. Akzeptiert werden sollen auch Typargumente, bei denen irgendeine Basisklasse das Interface Comparable implementiert. class BinaerBaumknoten<T extends Comparable<? { // Instanzvariable protected BinaerBaumknoten<T> links; protected BinaerBaumknoten<T> rechts; public T daten; super T>> // linker Teilbaum // rechter Teilbaum // Dateninhalt der Knoten // Konstruktor public BinaerBaumknoten(T datenElement) { this(datenElement, null, null ); } public BinaerBaumknoten(T datenElement, BinaerBaumknoten<T> l, BinaerBaumknoten<T> r) { daten = datenElement; links = l; rechts = r; } public void insert (T x) { if (x.compareTo(daten) > 0) // dann rechts { if (rechts == null) rechts = new BinaerBaumknoten<T>(x); else rechts.insert(x); } else // sonst links { if (links == null) links = new BinaerBaumknoten<T> (x); else links.insert(x); } } public BinaerBaumknoten<T> getLinks() { return links; } public BinaerBaumknoten<T> getRechts() { return rechts; } } Diese Art von Typebound befindet sich bspw. auch im Java-API der Klasse Collections. Upper- bzw. Lower-Typebounds gibt es auch in generischen Methoden, z.B.: public class TestGenericBinaerBaumKnotenLB { public static void main (String args[]) { BinaerBaumknoten<Integer> baum = null; 85 Algorithmen und Datenstrukturen /* for (int i = 0; i < 20; i++) // 20 Zusfallsstrings speichern { String s = "Zufallszahl " + (int)(Math.random() * 100); if (baum == null) baum = new BinaerBaumknoten(s); } print(baum); // Sortiert wieder ausdrucken */ for (int i = 0; i < 10; i++) { // Erzeuge eine Zahl zwischen 0 und 100 Integer r = new Integer((int)(Math.random()*100)); if (baum == null) baum = new BinaerBaumknoten<Integer>(r); else baum.insert(r); } System.out.println("Inorder-Durchlauf"); print(baum); System.out.println(); System.out.println("Baumdarstellung um 90 Grad versetzt"); ausgBinaerBaum(baum,0); System.out.print("Kleinster Wert: "); System.out.print(findeMin(baum)); System.out.println(); System.out.print("Groesster Wert: "); System.out.print(findeMax(baum)); System.out.println(); } public static <T extends Comparable<? super T>> void print (BinaerBaumknoten<? extends T> baum) // Rekursive Druckfunktion { if (baum == null) return; print(baum.getLinks()); System.out.print(baum.daten + " "); print(baum.getRechts()); } public static <T extends Comparable<? super T>> void ausgBinaerBaum(BinaerBaumknoten<T> b, int stufe) { if (b != null) { ausgBinaerBaum(b.getRechts(), stufe + 1); for (int i = 0; i < stufe; i++) { System.out.print(" "); } System.out.println(b.daten); ausgBinaerBaum(b.getLinks(), stufe + 1); } } public static <T extends Comparable<? super T>> T findeMin(BinaerBaumknoten<T> b) { return datenZugriff( findMin(b) ); } public static <T extends Comparable<? super T>> T findeMax(BinaerBaumknoten<T> b) { return datenZugriff( findMax(b) ); } public static <T extends Comparable<? super T>> T datenZugriff(BinaerBaumknoten<T> b) { return b == null ? null : b.daten; } public static <T extends Comparable<? super T>> BinaerBaumknoten<T> findMin(BinaerBaumknoten<T> b) { if (b == null) return null; else if (b.getLinks() == null) return b; return findMin(b.getLinks()); } 86 Algorithmen und Datenstrukturen public static <T extends Comparable<? super T>> BinaerBaumknoten<T> findMax(BinaerBaumknoten<T> b) { if (b != null) while (b.getRechts() != null) b = b.getRechts(); return b; } } 87 Algorithmen und Datenstrukturen 2. Datenstrukturen und Algorithmen in Java Datenstrukturen und Algorithmen sind eng miteinander verbunden. Die Wahl der richtigen Datenstruktur entscheidet über effiziente Laufzeiten. Beide erfüllen nur alleine ihren Zweck. Leider ist die Wahl der richtigen Datenstruktur nicht so einfach. Eine Reihe von schwierigen Problenem in der Informatik wurde deshalb noch nicht gelöst, da eine passende Datenorganisation bis heute noch nicht gefunden wurde. Wichtige Datenstrukturen (Behälterklassen, Collection, Container) werden in Java bereitgestellt. Auch Algorithmen befinden sich in diesen „Sammlungen“. Sammlungen (Kollektionen) sind geeignete Datenstrukturen (Behälter) zum Aufbewahren von Daten. Durch ihre vielfältigen Ausprägungen können sie zur Lösung unterschiedlicher Aufgaben herangezogen werden. Ein Lösungsweg umfaßt dann das Erzeugen eines solchen Behälters, das Einfügen, Modifizieren und Löschen der Datenelemente. Natürlich steht dabei im Mittelpunkt der Zugriff auf die Datenelemente, das Lesen der Dateninformationen und die aus diesen Informationen resultierenden Schlußfolgerungen. Verallgemeinert bedeutet dies: Das Suchen nach bestimmten Datenwerten, die in den Datenelementen der Datensammlung (Kollektion) gespeichert sind. Suchmethoden bestehen aus einer Reihe bestimmter Operationen. Im wesentlichen sind dies - Das Initialisieren der Kollektion ( die Bildung einer Instanz mit der Datenstruktur, auf der die Suche erfolgen soll - das Suchen eines Datenelements (z.B. eines Datensatzes oder mehrerer Datensätze)in der Datensammlung mit einem gegebenen Kriterium (z.B. einem identifizierenden Schlüssel) - das Einfügen eines neuen Datenelements. Bevor eingefügt werden kann, muß festgestellt werden, ob das einzufügende Element in der Kollektion schon vorliegt. - das Löschen eines Datenelements. Ein Datenelement kann nur dann gelöscht werden, falls das Element in der Kollektion vorliegt. Häufig werden Suchvorgänge in bestimmten Kollektionen (Tabellen) benötigt, die Daten über identifizierende Kriterien (Schlüssel) verwalten. Solche Tabellen können als Wörterbücher (dictionary) oder Symboltabellen implementiert sein. In einem Wörterbuch sind bspw. die „Schlüssel“ Wörter der deutschen Sprache und die Datensätze, die zu den Wörtern gehörenden Erläuterungen über Definition, Aussprache usw. Eine Symboltabelle beschreibt die in einem Programm verwendeten Wörter (symbolische Namen). Die Datensätze sind die Deklarationen bzw. Anweisungen des Programms. Für solche Anwendungen sind nur zwei weitere zusätzliche Operationen interessant: - Verbinden (Zusammenfügen) von Kollektionen, z.B. von zwei Wörterbüchern zu einem großen Wörterbuch - Sortieren von Sammlungen, z.B. des Wörterbuchs nach dem Schlüssel Die Wahl einer geeigneten Datenstruktur (Behälterklasse) ist der erste Schritt. Im zweiten Schritt müssen die Algorithmen implementiert werden. Die StandardBibliotheken der Programmiersprache Java bietet Standardalgorithmen an. 88 Algorithmen und Datenstrukturen 2.1 Kollektionen (Collections) 2.1.1 Durchwandern von Daten mit Iteratoren Bei Datenstrukturen gibt es eine Möglichkeit, gespeicherte Daten unabhängig von der Implementierung immer mit der gleichen Technik abzufragen. Bei Datenstrukturen handelt es sich meistens um Daten in Listen, Bäumen oder ähnlichem und oft wird nur die Frage nach der Zugehörigkeit eines Worts zum Datenbestand gestellt (z.B. „Gehört das Wort dazu?“). Auch die Möglichkeit Daten in irgendeiner Form aufzuzählen, ist eine häufig gestellte Aufgabe. Hierfür bieten sich Iteratoren an. In Java umfaßt das Interface Enumeration die beiden Funktionen hasMoreElements() und nextElement(), mit denen durch eine Datenstruktur iteriert werden kann. public interface Enumeration { public boolean hasMoreElements(); // Test, ob noch ein weiteres Element aufgezählt werden kann public Object nextElement() throws NoSuchElementException; /* setzt den internen Zeiger auf das nächste Element, d. h. liefert das das nächste Element der Enumertion zurück. Diese Funktion kann eine NoSuchException auslösen, wenn nextElement() aufgerufen wird, obwohl hasMoreElements() unwahr ist */ } Die Aufzählung erfolgt meistens über for (Enumeration e = ds.elements(); e.hasMoreElements(); ) System.out.println(e.nextElements()); Die Datenstruktur ds besitzt eine Methode elements(), die ein Enumeration-Objekt zurückgibt, das die Aufzählung erlaubt. 2.1.2 Die Klasse Vector class java.util.Vector extends AbstractList implements List, Cloneable, Serializable Die Klasse Vector beschreibt ein Array mit variabler Länge. Objekte der Klasse Vector sind Repräsentationen einer linearen Liste. Die Liste kann Elemente beliebigen Typs enthalten, ihre Länge ist zur Laufzeit veränderbar (Array mit variabler Länge). Vector erlaubt das Einfügen von Elementen an beliebiger Stelle, bietet sequentiellen und wahlfreien Zugriff auf die Elemente. Das JDK realisiert Vector als Array von Elementen des Typs Object. Der Zugriff auf Elemente erfolgt über Indizes. Es wird dazu aber kein Operator [], sondern es werden Methoden benutzt, die einen Index als Parameter annehmen. Anlegen eines neuen Vektors (Konstruktor): public Vector() public Vector(int initialCapacity,int capacityIncrement) // Ein Vector vergrößert sich automatisch, falls mehr Elemente aufgenommen werden, als // ursprünglich vorgesehen (Resizing). Dabei sollen initialCapacity und capacityIncrement // passend gewählt werden. Einfügen von Elementen: public void addElement(Object obj) // Anhängen an des Ende der bisher vorliegenden Liste von Elementen 89 Algorithmen und Datenstrukturen Eigenschaften: public final boolean isEmpty() // Prüfen, ob der Vektor leer ist public final int size() // bestimmt die Anzahl der Elemente public final int capacity() // bestimmt die interne Größe des Arrays. Sie kann mit ensureCapacity() geändert // werden Einfügen an beliebiger Stelle innerhalb der Liste: public void insertElementAt(Object obj, int index) throws ArrayIndexOutOfBoundsException // fügt obj an die Position index in den „Vector“ ein. Zugriff auf Elemente: Für den sequentiellen Zugriff steht ein Iterator zur Verfügung. Wahlfreier Zugriff erfolgt über: public Object firstElement() throws ArrayIndexOutOfBoundException; public Object lastElement() throws ArrayIndexOutOfBoundException; public Object elementAt(int index) throws ArrayIndexOutOfBoundException; firstElement() liefert das erste, lastElement() das letzte Element- Mit elementAt() wird auf das Element an der Position index zugegriffen. Alle 3 Methoden verursachen eine Ausnahme, wenn das gewünschte Element nicht vorhanden ist. Arbeitsweise des internen Arrays. Der Vector vergrößert sich automatisch, falls mehr Elemente aufgenommen werden (resizing). Die Größe des Felds. Mit capacity() erhält man die interne Größe des Arrays. Sie kann mit ensureCapacity() geändert werden. ensureCapacity(int minimumCapacity) bewirkt bei einem Vector, daß er mindestens minCapacity Elemente aufnehmen soll. Der Vektor verkleinert nicht die aktuelle Kapazität, falls sie schon höher als minCapacity ist. Zur Veränderung dieser Größe, dient die Methode trimToSize(). Sie reduziert die Kapazität des Vectors auf die Anzahl der Elemente, die gerade im Vector sind. Die Anzahl der Elemente kann über die Methode size() erfragt werden. Sie kann über setSize(int newSize) geändert werden. Ist die neue Größe kleiner als die alte, so werden die Elemente am Ende des Vectors abgeschnitten. Ist newSize größer als die alte Größe, werden die neu angelegten Elemente mit null initialisiert. Bereitstellen des Interface Enumerartion. In der Klasse Vector liefert die Methode public Enumeration elements() einen Enumerator (Iterator) für alle Elemente, die sich in Vector befinden. 90 Algorithmen und Datenstrukturen Vector << Konstruktoren >> public Vector() // Ein Vector in der Anfangsgröße von 10 Elementen wird angelegt public Vector(int startKapazitaet) // Ein Vector enthält Platz für startKapazitaet Elemente public Vector(int startKapazitaet, int kapazitaetsSchrittweite) << Methoden >> public final synchronized Object elementAt(int index) // Das an der Stelle index befindliche Objekt wird zurückgegeben public final int size() public final synchronized Object firstElement() public final synchronized Object lastElement(); public final synchronized void insertElementAt(Object obj, int index) // fügt Object obj an index ein und verschiebt die anderen Elemente public final synchronized void setElementAt(Object obj, int index) public final synchronized copyInto(Object einArray[]) // kopiert die Elemente des Vektors in das Array einArray // Falls das bereitgestellte Objektfeld nicht so groß ist wie der Vektor, // dann tritt eine ArrayIndexOutOfBounds Exception public final boolean contains(Object obj) // sucht das Element, liefert true zurück wenn o im Vector vorkommt public final int indexOf(Object obj) // sucht im Vector nach dem Objekt obj. Falls obj nicht in der Liste ist, wird // -1 übergeben public final int lastIndexOf(Object obj) public final synchronized boolean removeElement(Object obj) // entfernt obj aus der Liste. Konnte es entfernt werden, wird true // zurückgeliefert public final synchronized void removeElementAt(int index) // entfernt das Element an Stelle index public final synchronized void removeAllElements() // löscht alle Elemente public final int capacity() // gibt an, wieviel Elemente im Vektor Patz haben // (ohne automatische Größenanpassung) public synchronized Object clone() // Implementierung der clone()-Methode von Object // das kopierte Feld wird zurückgegeben. Die Kopie ist flach. public final synchronized String toString() Abb.: Die Klasse Vector 91 Algorithmen und Datenstrukturen 2.1.3 Die Klasse Stack class java.util.Stack extends Vector Ein Stack ist eine nach dem LIFO-Prinzip arbeitende Datenstruktur. Elemente werden vorn (am vorderen Ende der Liste) eingefügt und von dort auch wieder entnommen. In Java ist ein Stack eine Ableitung von Vector mit neuen Zugriffsfunktionen für die Implementierung des typischen Verhaltens von einem Stack. Konstruktor: public Stack(); Hinzufügen neuer Elemente: public Object push(Object item); Zugriff auf das oberste Element: public Object pop(); // Zugriff und Entfernen des obersten Element public Object peek() // Zugriff auf das oberste Element Suche im Stack: public int search(Object o) // Suche nach beliebigem Element, // Rueckgabewert: Distanz zwischen gefundenem und // obersten Stack-Element bzw. –1, // falls das Element nicht da ist. Test: public boolean empty() // bestimmt, ob der Stack leer ist Vector Stack public Stack() public Object push(Object obj) public synchronized Object pop() public synchronized Object peek() public synchronized int search(Object obj) public boolean empty() Abb.: Die Klasse Stack Anwendungen: 1. Umrechnen von Dezimalzahlen in andere Basisdarstellungen Aufgabenstellung: Defaultmäßig werden Zahlen dezimal ausgegeben. Ein Stapel, der Ganzzahlen aufnimmt, kann dazu verwendet werden, Zahlen bezogen auf eine andere Basis als 10 darzustellen. Die Funktionsweise der Umrechnung von Dezimalzahlen in eine Basis eines anderen Zahlensystem zeigen die folgenden Beispiele: 92 Algorithmen und Datenstrukturen 2810 = 3 ⋅ 8 + 4 = 34 8 72 10 = 1 ⋅ 64 + 0 ⋅ 16 + 2 ⋅ 4 + 0 = 1020 4 5310 = 1 ⋅ 32 + 1 ⋅ 16 + 0 ⋅ 8 + 1 ⋅ 4 + 0 ⋅ 2 + 1 = 1101012 Mit einem Stapel läßt sich die Umrechnung folgendermaßen unterstützen: 6 leerer Stapel n = 355310 7 7 4 4 4 1 1 1 1 n%8=1 n/8=444 n%8=4 n/8=55 n = 444 10 n%8=7 n/8=6 n = 5510 n = 610 n%8=6 n/6=0 n = 010 Abb.: Umrechnung von 355310 in 67418 mit Hilfe eines Stapel Algorithmus zur Lösung der Aufgabe: 1) Die am weitesten rechts stehende Ziffer von n ist n%b. Sie ist auf dem Stapel abzulegen. 2) Die restlichen Ziffern von n sind bestimmt durch n/b. Die Zahl n wird ersetzt durch n/b. 3) Wiederhole die Arbeitsschritte 1) und 2) bis keine signifikanten Ziffern mehr übrig bleiben. 4) Die Darstellung der Zahl in der neuen Basis ist aus dem Stapel abzulesen. Der Stapel ist zu diesem Zweck zu entleeren. Implementierung: Das folgende kleine Testprogramm 50 realisiert den Algorithmus und benutzt dazu eine Instanz von Stack. import java.util.*; public class PR61210 { public static void main(String[] args) { int zahl = 3553; // Dezimalzahl int b = 8; // Basis Stack s = new Stack(); // Stapel do { s.push(new Integer(zahl % b)); zahl /= b; } while (zahl != 0); while (!s.empty()) { System.out.print(s.pop()); } System.out.println(); } } 50 pr61210 93 Algorithmen und Datenstrukturen Ein Stack ist ein Vector. Die Vector-Klasse wird von der Klasse Stack erweitert. Das ist sicherlich nicht immer besonders sinnvoll. Funktionen, die im Gegensatz zur Leistungsfähigkeit eines Stapels stehen sind add(), addAll(), addElement(), capacity(), clear(), clone(), contains(), copyInto(), elementsAt(), .... . 2.1.4 Die Klasse Bitset für Bitmengen class java.util.BitSet implements Cloneable, Serializable Die Klasse Bitset bietet komfortable Möglichkeiten zur bitweisen Manipulation von Daten. Bitset anlegen und füllen. Mit zwei Methoden lassen sich die Bits des Bitsets leicht ändern: set(bitNummer) und clear(bitNummer). Mengenorintierte Operationen. Das Bitset erlaubt mengenorientierte Operationen mit einer weiteren Menge. BitSet public void and(BitSet bs) public void or(BitSet bs) public void xor(BitSet bs) public void andNot(Bitset set) // löscht alle Bits im Bitset, dessen Bit in set gesetzt sind public void clear(int index) // Löscht ein Bit. Ist der Index negativ, kommt es // zur Auslösung von IndexOutOfBoundsException public void set(int index) // Setzt ein Bit. Ist der Index negativ, kommt es // zur Auslösung von IndexOutOfBoundsException public boolean get(int index) // liefert den Wert des Felds am übergebenen Index, // kann IndexOutOfBoundsException auslösen. public int size() public boolean equals(Object o) // Vergeicht sich mit einem anderen Bitset-Objekt o. Abb.: Die Klasse BitSet 94 Algorithmen und Datenstrukturen 2.1.5 Die Klasse Hashtable und assoziative Speicher Eine Hashtabelle (Hashtable) ist ein assoziativer Speicher, der Schlüssel (keys) mit Werten verknüpft. Die Datenstruktur ist mit einem Wörterbuch vergleichbar. Die Hashtabelle arbeitet mit Schlüssel/Werte Paaren. Aus dem Schlüssel wird nach einer Funktion – der sog. Hashfunktion – ein Hashcode berechnet. Dieser dient als Index für ein internes Array. Dieses Array hat zu Anfang ein feste Grösse. Leider hat dieses Technik einen entscheidenden Nachteil. Besitzen zwei Wörter denselben Hashcode, dann kommt es zu einer Kollision. Auf ihn muß die Datenstruktur vorbereitet sein. Hier gibt es verschiedene Lösungsansätze. Die unter Java implementierte Variante benutzt eine verkettete Liste (separate Chaining). Falls eine Kollision auftritt, so wird der Hashcode beibehalten und der Schlüssel bzw. Wert in einem Listenelement an den vorhandenen Eintrag angehängt. Wenn allerdings irgendwann einmal eine Liste durchsucht werden muß, dann wird die Datenstruktur langsam. Ein Maß für den Füllgrad ist der Füllfaktor (Load Factor). Dieser liegt zwischen 0 und 100 %. 0 bedeutet: kein Listenelement wird verwendet. 100 % bedeutet: Es ist kein Platz mehr im Array und es werden nur noch Listen für alle zukommenden Werte erweitert. Der Füllfaktor sollte für effiziente Anwendungen nicht höher als 75% sein. Ist ein Füllfaktor nicht explizit angegeben, dann wird die Hashtabelle „rehashed“, wenn mehr als 75% aller Plätze besetzt sind. class java.util.Hashtable extends Dictionary implements Map, Cloneable, Serializable Erzeugen von einem Objekt der Klasse HashTable: public Hashtable() /* Die Hashtabelle enthält eine Kapazität von 11 Einträgen und einen Füllfaktor von 75 % */ public HashTable(int initialCapacity) /* erzeugt eine Hashtabelle mit einer vorgebenen Kapazität und dem Füllfaktor 0.75 */ public HashTable(int initialCapacity, float loadFactor) /* erzeugt eine Hashtabelle mit einer vorgebenen Kapazität und dem angegebenen Füllfaktor */ Daten einfügen: public Object put(Object key, Object value) /* speichert den Schlüssel und den Wert in der Hashtabelle. Falls sich zu dem Schlüssel schon ein Eintrag in der Hashtabelle befand, so wird dieser zurückgegeben. Anderenfalls ist der Rückgabewert null. Die Methode ist vorgegeben vom Interface Map. Es überschreibt die Methode von der Superklasse Dictionary. */ Daten holen: public Object get(Object key) Schlüssel entfernen. public Object remove(Object key) Löschen der Werte. public void clear() Test. public boolean containsKey(Object key) // Test auf einen bestimmten Schlüssel public boolean containsValue(Object value) // Test auf einen bestimmten Wert Aufzählen der Elemente. Mit keys() und elements() bietet die Hashtabelle zwei Methoden an, die eine Aufzählung zurückgeben: public Enumeration keys() // liefert eine Aufzählung aller Schlüssel, überschreibt keys() in Dictionary. public Enumeration elements() // liefert eine Aufzählung der Werte, überschreibt elements() in Dictionary 95 Algorithmen und Datenstrukturen Wie üblich liefern beide Iteratoren ein Objekt, welches das Interface Enumeration implementiert. Der Zugriff erfolgt daher mit Hilfe der Methoden hasMoreElements() und nextElement(). Dictionary {abstract} public abstract Object put (Object key, Object value) publicc abstract Object get(Object key) public abstract Enumeration elements() public abstract Enumeration keys() public abstract int size() public absztract boolean isEmpty() public abstract Object remove(Object key) Hashtable Map << Konstruktor >> public Hashtable(int initialKapazitaet) public Hashtable(int initialKapazitaet, float Ladefaktor) public Hashtable() << Methoden >> public synchronized boolean contains(Object wert) public synchronized boolean containsKey(Object key) public synchronized void clear() public synchronized Object clone() protected void rehash() public synchronized String toString() Properties << Konstruktor >> public Properties() // legt einen leeren Container an public Properties(Properties defaults) // füllt eine Property-Liste mit den angegebenen Default-Werten << Methoden >> public String getProperty(String key) public String getProperty(String key, String defaultKey) public synchronized void load(InputStream in) throws IOException // Hier muß ein InputStream übergeben werden, der die daten der // Property-Liste zur Verfügung stellt. public synchronizred void save(OutputStream out, String header) public void list(PrintStream out) public void list(PrintWriter out) public Enumeration propertyNames() // beschafft ein Enumerations-Objekt mit denen Eigenschaften // der Property-Liste aufgezählt werden können Abb.: Die Klassen Hashtable und Properties 96 Algorithmen und Datenstrukturen Die Klasse Hashtable ist eine Konkretisierung der abstrakten Klasse Dictionary. Diese Klasse beschreibt einen assoziativen Speicher, der Schlüssel auf Werte abbildet und über den Schlüsselbegriff einen effizienten Zugriff auf den Wert ermöglicht. Einfügen und der Zugriff auf Schlüssel erfolgt nicht auf der Basis des Operators „==“, sondern mit Hilfe der Methode „equals“. Schlüssel müssen daher lediglich inhaltlich gleich sein, um als identisch angesehen zu werden. Bsp. 51: Hashtabelle zum Test der Zufallszahlen der Methode Math.random(). import java.util.*; class Zaehler { int i = 1; public String toString() { return Integer.toString(i); } } public class Statistik { public static void main(String args[]) { Hashtable h = new Hashtable(); for (int i = 0; i < 10000; i++) { // Erzeuge eine Zahl zwischen 0 und 20 Integer r = new Integer((int)(Math.random() * 20)); if (h.containsKey(r)) ((Zaehler) h.get(r)).i++; else h.put(r,new Zaehler()); } System.out.println(h); } } Die Klasse Hashtable benutzt das Verfahren der Schlüsseltransformation (HashFunktion) zur Abbildung von Schlüsseln auf Indexpostionen eines Arrays. Die Kapazität der Hash-Tabelle gibt die Anzahl der Elemente an, die insgesamt untergebracht werden können. Der Ladefaktor zeigt an, bei welchem Füllungsgrad die Hash-Tabelle vergrößert werden muß. Das Vergrößern erfolgt automatisch, falls die Anzahl der Elemente innerhalb der Tabelle größer ist als das Produkt aus Kapazität und Ladefaktor. Seit dem JDK 1.2 darf der Ladefaktor auch größer als 1 sein. In diesem Fall wird die Hash-Tabelle erst dann vergrößert, wenn der Füllungsgrad größer als 100% ist und bereits ein Teil der Elemente in den Überlaufbereichen untergebracht wurde. Die Klasse Hashtable ist eine besondere Klasse für Wörterbücher. Ein Wörterbuch ist eine Datenstruktur, die Elemente miteinander assoziiert. Das Wörterbuchproblem ist das Problem, wie aus dem Schlüssel möglichst schnell der zugehörige Wert konstruiert wird. Die Lösung des Problems ist: Der Schlüssel wird als Zahl kodiert (Hashcode) und dient in einem Array als Index. An einem Index hängen dann noch die Werte mit gleichem Hashcode als Liste an. 51 vgl. pr13215 97 Algorithmen und Datenstrukturen 2.1.6 Die abstrakte Klasse Dictionary Die Klasse Dictionary ist eine abstrakte Klasse, die Methoden anbietet, wie Objekte (also Schlüssel und Wert) miteinander assoziiert werden: public abstract Object put(Object key,Object value) // fügt den Schlüssel key mit dem verbundenen Wert value in das Wörterbuch // ein public abstract Object get(Object key) // // // // liefert das zu key gehörende Objekt zurück. Falls kein Wert mit dem Schlüssel verbunden ist, so liefert get() eine null. Eine null als Schlüssel oder Wert kann nicht eingesetz werden. In put() würde das zu einer NullPointerException führen. public abstract Object remove(Object key) // entfernt ein Schlüssel/Wertepaar aus dem Wörterbuch. Zurückgegeben wird // der assoziierte Wert. public abstract boolean isEmpty() // true, falls keine Werte im Wörterbuch public int size() gibt zurück, wie viele Elemente aktuell im Wörterbuch sind. public abstract Enumeration keys() // liefert eine Enumeration für alle Schlüssel public abstract Enumeration elements() // liefert eine Enumeration über alle Werte. 2.1.7 Die Klasse Properties Die Properties Klasse ist eine Erweiterung von Hashtable. Ein Properties Objekt erweitert die Hashtable um die Möglichkeit, sich unter einem wohldefinierten Format über einen Strom zu laden und zu speichern. Erzeugen. public Properties() // erzeugt ein leeres Propertes Objekt ohne Worte. public Properties(Properties p) // erzeugt ein leeres Properties Objekt mit Standard-werten aus den // übergebenen Properties Die Methode getProperty(). public String getProperty(String s) // sucht in den Properties nach der Zeichenkette public String getProperty(String key, String default) // sucht in den Properties nach der Zeichenkette key. Ist dieser nicht // vorhanden, wird der String default zurückgegeben Eigenschaften ausgeben. Die Methode list() wandert durch die Daten und gibt sie auf einem PrintWriter aus: public void list(PrintWriter pw) // listet die Properties auf dem PrintWriter aus. 98 Algorithmen und Datenstrukturen 2.2 Das Collection Framework Die Java 2 Plattform hat Java erweitert um das Collection API. Anstatt Collection kann man auch Container (Behälter) sagen. Ein Container ist ein Objekt, das wiederum Objekte aufnimmt und die Verantwortung für die Elemente übernimmt. Im „util“-Paket befinden sich sechs Schnittstellen, die grundlegende Eigenschaften der Containerklassen definieren. Das in Java 1.2 enthaltene Collections Framework beinhaltet im Wesentlichen drei Grundformen: Set, List und Map 52. Jede dieser Grundformen ist als Interface implementiert. Die Interfaces List und Set sind direkt aus Collection 53 abgeleitet. Es gibt auch noch eine abstrakte Implementierung des Interface, mit dessen Hilfe das Erstellen eigener Collections erleichtert wird. Bei allen Collections, die das Interface Collection implementieren, kann ein Iterator zum Durchlaufen der Elemente mit der Methode „iterator()“ beschafft werden. Zusätzlich fordert die JDK 1.2-Spezifikation für jede Collection-Klasse zwei Konstruktoren: - Einen parameterlosen Konstruktor zum Anlegen einer neuen Collection. - Ein mit einem einzigen Collection-Argument ausgestatteter Konstruktor, der eine neue Collection anlegt und mit den Elementen der als Argument übergebenen Collection auffüllt. Collections konnen mit foreach-Schleifen durchlaufen werden. 2.2.1 Die Schnittstellen Collection, Iterator, Comparator Das Interface Collection bildet die Basis der Collection-Klasse und –Interfaces des JDK 1.2. Alle Behälterklassen implementieren das Collection Interface und geben den Klassen damit einen äußeren Rahmen. 52 53 Maps speichern Element-Paare. Alle Klassen aus dieser Gruppe implementieren das Interface Map. Collections speichern Einzelelemente 99 Algorithmen und Datenstrukturen Das Interface Collection << interface >> Collection public void clear(); // Optional: Löscht alle Elemente in dem Container. Eird dies vom Container nicht unterstützt, // kommt es zur UnSupportedOperationException public boolean add(Object o); // Optional: Fügt ein Objekt dem Container hinzu und gibt true zurück, falls sich das Element // einfügen läßt. Gibt false zurück, falls schon ein Objektwert vorhanden ist und doppelte Werte // nicht erlaubt sind. public boolean add(Tt); // fügt das Element t ein. Das Ergebnis zeigt an, ob tatsächlich ein Element eingefägt wurde. public boolean addAll(Collection c); // fügt alle Elemente der Collection c dem Container hinzu public boolean remove(Object o); // Entfernen einer einzelnen Instanz. Rückgabewert ist true, wenn das Element gefunden und // entfernt werden konnte public boolean remove(T t); // löscht das Element t. Das Ergebnis zeigt an, ob tatsächlich ein Element gelöscht wurde public boolean removeAll(Collection c); // Oprtional: Entfernt alle Objekte der Collection c aus dem Container public boolean contains(Object o); // liefert true, falls der Container das Element enthält public boolean contains(T t); // gibt Auskunft, ob das Element t in dieser Collection enthalten ist // Rückgabewert ist true, falls das vorgegebene Element gefunden werden konnte public boolean containsAll(Collection c); // liefert true, falls der Container alle Elemente der Collection c enthält. public boolean equals(Object o); // vergleicht das angegebene Objekt mit dem Container, ob die gleichen Elemente vorkommen. public boolean isEmpty(); // liefert true, falls der Container keine Elemente enthält public int size(); // gibt die Größe des Containers zurück (Anzahl der Elemente) public boolean retainAll(Collection c); public Iterator iterator(); // liefert Iterator über die Kollektion publicObject [] toArray(); // gibt ein Array mit Elementen des Containers zurück public Object [] toArray(Object [] a); public int hashCode(); // liefert den Hashwert des Containers public String toString() // Rückgabewert ist die Zeichenketten-Repräsentation der Kollektion. Abb.: Das Interface Collection Die abstrakte Basisklasse AbstractCollection implementiert die Methoden des Interface Collection (ohne iterator() und size()). AbstractCollection ist die Basisklasse von AbstractList und AbstractSet. 100 Algorithmen und Datenstrukturen Das Interface Iterator Ein Iterator durchläuft von Beginn an elementweise durch eine Kollektion. Sprünge sind nicht möglich. Ein Iterator ist verbraucht, wenn er am Ende angekommen ist. Er kann nicht wiederverwendet werden. Statt dessen erzeugt man für einen nächsten Durchlauf einen neuen Iterator. Innerhalb einer Kollektion können gleichzeitig mehrere Iteratoren unterwegs sein. Sie sind unabhängig voneinander und können einzeln bewegt werden. << interface >> Iterator public boolean hasNext(); // gibt true zurück, wenn der Iterator mindestens ein weiteres Element enthält. public Object next(); // liefert das nächste Element bzw. löst eine Ausnahme des Typs NoSuchElementException // aus, wenn es keine weiteren Elemente gibt public void remove(); // entfernt das Element, das der Iterator bei next() geliefert hat. Abb.: Bei allen Collections, die das Interface Collection implementieren, kann ein Iterator zum Durchlaufen der Elemente mit der Methode „iterator()“ beschafft werden. Das Interface Comparator Vergleiche zwischen Objekten werden mit speziellen Objekten vorgenommen, den Comparatoren. Ein konkreter Comparator implementiert die folgende Schnittstelle. << interface >> java.util.Comparator public int compare(Object o1, Object o2) // vergleicht 2 Argumente auf ihre Ordnung public boolean equals(Object arg) // testet, ob zwei Objekte bzgl. des Comparator-Objekts gleich sind Abb. 101 Algorithmen und Datenstrukturen 2.2.2 Die Behälterklassen und Schnittstellen des Typs List Behälterklassen des Typs List fassen eine Menge von Elementen zusammen, auf die sequentiell oder über Index (-positionen) zugegriffen werden kann. Wie Vektoren der Klasse Vector 54 hat das erste Element den Index 0 und das letzte den Index „size() – 1“. Es ist möglich an einer beliebigen Stelle ein Element einzufügen oder zu löschen. Die weiter hinten stehenden Elemente werden dann entsprechend weiter nach rechts bzw. nach links verschoben. Das Interface List 55 << interface >> List public void add(int index, Object element); // Einfügen eines Elements an der durch Index spezifizierten Position public boolean add(Object o); // Anhängen eines Elements ans Ende der Liste // Rückgabewert ist true, falls die Liste durch den Aufruf von add verändert wurde. Er ist false, // wenn die Liste nicht verändert wurde. Das kann bspw. der Fall sein, wenn die Liste keine // Duplikate erlaubt und ein bereits vorhandenes Element noch einmal eingefügt werden soll. // Konnte das Element aus einem anderen Grund nicht eingefügt werden, wird eine Ausnahme // des Typs UnsupportedOperationException, CallsCastException oder IllegalArgumentException // ausgelöst public boolean addAll(Collection c); // Einfügen einer vollständigen Collection in die Liste. Der Rückgabewert ist true, falls die Liste // durch den Ausfruf von add veränder wurde public boolean addAll(int index, Collection c) public void clear(); public boolean equals(Object object); public boolean contains(Object element); public boolean containsAll(Collection collection); public int indexOf(T t); // ersetzt das Element an Indexposition i durch t. Als Ergebnis wird das alte Element zurückgeliefert. public T lastIndexOf(T t) // wie indexOf(), sucht aber das letzte Vorkommen von t public Object remove(int index) public boolean remove(Object element); public boolean removeAll(Collection c); // Alle Elemente werden gelöscht, die auch in der als Argument angebenen // Collection enthalten sind. public boolean retainAll(Collection c); // löscht alle Elemente außer den in der Argument-Collection enthaltenen public Object get(); public T get(int I); // liefert das Element an Indexposition i. Indexfehler lösen eine Exception vom Typ // IndexOutOfBoundsExcetion aus public int hashCode(); public Iterator iterator(); public ListIterator listIterator(): public ListIterator listIterator(int startIndex); public Object set(int index, Obeject element); public T set(int I,T t) 54 seit Java 1.2 implementiert die Klasse Vector die Schnittstelle List Da ebenfalls das AWT-Paket eine Klasse mit gleichen namen verwendet, muß der voll qualifizierte Name in Anwendungen benutzt werden. 55 102 Algorithmen und Datenstrukturen // ersetzt das Element an Indexposition i durch t. Als Ergebnis wird das alte Element zurückgeliefert. public List subList(int fromIndex, int toIndex); public Object [] toArray(); public Object [] toArray(Object [] a); Abb.: Auf die Elemente einer Liste läßt sich mit einem Index zugreifen und nach Elementen läßt sich mit linearem Aufwand suchen. Doppelte Elemente sind erlaubt. Die Schnittstelle List, die in ArrayList und LinkedList eine Implementierung findet, erlaubt sequentiellen Zugriff auf die gespeicherten gespeicherten Elemente. Das Interface List wird im JDK von verschiedenen Klassen implementiert: AbstractList ist eine abstrakte Basisklasse (für eigene List-Implementierungen), bei der alle Methoden die Ausnahme UnsupportedException auslösen und diverse Methoden abstract deklariert sind. Die direkten Subklassen sind AbstractSequentialList, ArrayList und java.util.Vector. AbstractList implementiert bereits viele Methoden für die beiden Listen-Klassen 56: abstract class AbstractList extends AbstractCollection implements List << Methoden >> public void add(int index, Object element) // Optional: Fügt ein Objekt an der spezifizierten stelle ein public boolean add(Object o) // Optional: Fügt das Element am Ende an public boolean addAll(int index, Collection c) // Optional: Fügt alle Elemente der Collection ein public void clear() // Optional: Löscht alle Elemente public boolean equals(Object o) // vergleicht die Liste mit dem Objekt public abstract Object get(int index) // liefert das Element an dieser Stelle int hashCode() // liefert HashCode der Liste int indexOf(Object o) // liefert Position des ersten Vorkommens für o oder –1, // wenn das Element nicht existiert. Iterator iterator() // liefert den Iterator. Überschreibt die Methode AbstractCollection, // obwohl es auch listIterator() für die spezielle Liste gibt. Die Methode // ruft aber listIterator() auf und gibt ein ListIterator-Objekt zurück Object remove(int index) // löscht ein Element an Position index. protected void removeRange(int fromIndex, int toIndex) // löscht Teil der Liste von fromIndex bis toIndex. fromIndex wird mitgelöscht, // toIndex nicht. public Object set(int index, Object element) // Optional. Ersetzt das Element an der Stelle index mit element. public List subList(int fromIndex, int toIndex) // liefert Teil einer Liste fromIndex (einschließlich) bis toIndex (nicht mehr dabei) 56 Beim Aufruf einer optionalen Methode, die von der Subklasse nicht implementiert wird, führt zur UnsupportedOperationException. 103 Algorithmen und Datenstrukturen Abb.: AbstractSequentialList bereitet die Klasse LinkedList darauf vor, die Elemente in einer Liste zu verwalten und nicht wie ArrayList in einem internen Array. LinkedList realisiert die doppelt verkettete, lineare Liste und implementiert List. ArrayList implementiert die Liste als Feld von Elementen und implementiert List. Da Arraylist ein Feld ist, ist der Zugriff auf ein spezielles Element sehr schnell. Eine LinkedList muß aufwendiger durchsucht werden. Die verkettete Liste ist aber deutlich im Vorteil, wenn Elemente gelöscht oder eingefügt werden. << interface >> Collection << interface >> List LinkedList ArrayList << Konstruktor >> public LinkedList(); public LinkedList(Collection collection); << Konstruktor public ArrayList(); public ArrayList(Collection collection); public ArrayList(int anfangsKapazitaet); << Methoden >> public void addFirst(Object object); public void addLast(Object object); public Object getFirst(); public Object getLast(); public Object removeFirst(); public Object removeLast(); << Methoden >> protected void removeRange (int fromIndex, int toIndex) // löscht Teil der Liste von // fromIndex bis toIndex. fromIndex wird // mitgelöscht, toIndex nicht. Abb. 104 Vector Algorithmen und Datenstrukturen Das Interface ListIterator << interface >> ListIterator public boolean hasPrevious(); // bestimmt, ob es vor der aktuellen Position ein weiteres Element gibt, der Zugriff ist mit // previous möglich public boolean hasNext(); public Object next(); public Object previous(); public int nextIndex(); puplic int previousIndex(); public void add(Object o); // Einfügen eines neuen Elements an der Stelle der Liste, die unmittelbar vor dem nächsten // Element des Iterators liegt public void set(Object o); // erlaubt, das durch den letzten Aufruf von next() bzw. previous() beschaffene Element zu // ersetzen public void remove(); Abb.: ListIterator ist eine Erweiterung von Iterator. Die Schnittstelle fügt noch Methoden hinzu, damit an aktueller Stelle auch Elemente eingefügt werden können. Mit einem ListIterator läßt sich rückwärts laufen und auf das vorgehende Element zugreifen. Bsp.: 1. Simulation einer Schlange 57 public class Queue { private java.util.LinkedList list = new java.util.LinkedList(); public Queue() { } public void clear() { list.clear(); } public boolean isEmpty() { return list.isEmpty(); } public Object firstEl() { return list.getFirst(); } public Object dequeue() { return list.removeFirst(); } public void enqueue(Object el) { list.add(el); } public String toString() { return list.toString(); } } Eine verkettete Liste hat neben den normalen Funktionen aus AbstractList noch weitere Hilfsmethoden zur Implementierung von einem Stack oder einer Schlange. Es handelt sich dabei um die Methoden addFirst(), addLast(), getFirst(), getLast() und removeFirst(). import java.util.*; public class ListBsp { public static void main(String [] args) { LinkedList schlange = new LinkedList(); schlange.add("Thomas"); schlange.add("Andreas"); 57 Vgl. pr22220 105 Algorithmen und Datenstrukturen schlange.add("Josef"); System.out.println(schlange); schlange.removeFirst(); schlange.removeFirst(); System.out.println(schlange); } } 2. Entfernen von Duplikaten 58 import java.util.*; public class EntfDupl { public static void main(String args[]) { int [] a = { 1, 7, 7, 1, 5, 1, 2, 7, 2, 1, 6, 6, 3, 6, 7 }; LinkedList l = new LinkedList(); for (int i = 0; i < a.length; i++) { l.add(new Integer(a[i])); } System.out.println(l); int i = 0; do { int aktWert = ((Integer) l.get(i)).intValue(); i++; if (i == l.size()) break; int j = i; do { int wert = ((Integer) l.get(j)).intValue(); if (wert == aktWert) l.remove(j); j++; } while (j < l.size()); System.out.println(l); } while (i < l.size()); } } 58 vgl. pr22220 106 Algorithmen und Datenstrukturen 2.2.3 Queues Eine Queue arbeitet nach dem FIFO-Prinzip: Zuerst eingeführte Elemente werden zuerst wieder ausgegeben. <<interface>> java.lang.Iterabe<T> <<interface>> java.util.Collection<E> <<interface>> java.util.Queue<E> <<interfave>> java.util.Deque<E> <<interface>> java.util.List<E> java.util.LinkedList Abb.: Die Schnittstelle Queue für (Warte-) Schlangen 59 Die Schnittstelle Queue erweitert Collection und ist somit auch vom Typ Iterable. public interface Queue<E> extends Collection<E> { E element() boolean offer(E o) E peek() E poll() E remove() } Die Schnittstelle Deque 59 http://www.galileocomputing.de/openbook/javainsel7/javainsel_12_007.htm Stand März 2008 107 Algorithmen und Datenstrukturen Die Datenstruktur Deque 60 (double ended queue) hängt an beiden Enden Daten. Blockierende Queues und Prioritätswarteklassen Die Schnittstelle java.util.concurrent.BlockingQueue erweitert die Schnittstelle java.util.Queue. Klassen, die BlockingQueue implementieren, blockieren, falls eine Operation wegen fehlender Daten nicht durchgeführt werden kann. ConcurrentQueue DelayQueue ArrayBlockingQueue PriorityQueue. Hält in einen Heap-Speicher Elemente sortiert 61 und liefert bei Anfragen das jeweils kleinste Element. Wie beim TreeSet 62 müssen die Elemente entweder Comparable implementieren oder es muß ein Comperator angegeben werden. PriorityBlockingQueue. Wie PriorityQueue, nur blockierend. SynchronousQueue Die Priority-Klassen implementieren im Gegensatz zu den übrigen Klassen kein FIFO-Verhalten. 60 Deque wird als „Deck“ ausgesprochen http://java.sun.com/j2se/1.5.0/docs/api/java/util/PriorityQueue.html Stand: März 2008 62 vgl. 2.2.4 61 108 Algorithmen und Datenstrukturen 2.2.4 Behälterklassen des Typs Set Ein Set ist eine Menge, in der keine doppelten Einträge vorkommen können. Set hat die gleichen Methoden wie Collection. Standard-Implementierung für Set sind das unsortierte HashSet (Array mit veränderlicher Größe) und das sortierte TreeSet (Binärbaum). Die Schnittstelle Set Ist eine im mathematischen Sinne definierte Menge von Objekten. Die Reihenfolge wird durch das Einfügen festgelegt. Wie von mathematischen Mengen bekannt, darf ein Set keine doppelten Elemente enthalten. Besondere Beachtung muß Objekten geschenkt werden, die ihren Wert nachträglich ändern. Die kann ein Set nicht kontrollieren. Eine Menge kann sich nicht selbst als Element enthalten. Zwei Klassen ergeben sich aus Set: die abstrakte Klasse AbstractSet und die konkrete Klasse HashSet. Die Schnittstelle SortedSet erweitert Set so, daß Elemente sortiert ausgelesen werden können. Sortierkriterium kann sein - Comparable. Elemente müssen Comparable Interface implementieren, Vergleich der Elemente erfolgt mit compareTo(). - Comperator. SortedSet wird ein eigenes Comperator-Objekt übergeben, mit denen die Elemente bearbeitet werden können Bsp. 63: import java.util.*; public class SetBeispiel { public static void main(String args []) { Set set = new HashSet(); set.add("Gerhard"); set.add("Thomas"); set.add("Michael"); set.add("Peter"); set.add("Christian"); set.add("Valentina"); System.out.println(set); Set sortedSet = new TreeSet(set); System.out.println(sortedSet); } } 63 Vgl. pr13230 109 Algorithmen und Datenstrukturen << interface >> Collection << interface >> Set public boolean add(Object element); public boolean addAll(Collection collection); public void clear(); public boolean equals(Object object); public boolean contains(Object element); public boolean containsAll(Collection collection); public int hashCode(); public Iterator iterator(); public boolean remove(Object element); public boolean removeAll(Collection collection); public boolean retainAll(Collection collection); public int size(); public Object[] toArray(); public Object[] toArray(Object[] a); HashSet << interface >> SortedSet public HashSet(); public HashSet(Collection collection); public HashSet(int anfangskaazitaet); public HashSet(int anfangskapazitaet, int ladeFaktor); public Object first(); public Object last(); public SortedSet headSet(Object toElement); public SortedSet subSet(Object fromElement, Object toElement); public SortedSet tailSet(Object fromElement); public Comparator comparator(); public Object fisrt(); public Object last(); TreeSet 64 public TreeSet() public TreeSet(Collection collection); public TreeSet(Comparator vergleich); public TreeSet(SortedSet collection); 64 implementiert die sortierte Menge mit Hilfe der Klasse TreeMap, verwendet einen Red-Black-Tree als Datenstruktur 110 Algorithmen und Datenstrukturen 2.2.5 Behälterklassen des Typs Map Ein Map ist eine Menge von Elementen, auf die über Schlüssel zugegriffen wird. Jedem Schlüssel (key) ist genau ein Wert (value) zugeordnet. StandardImplementierungem sind HashMap, HashTable und TreeMap. Interface Map, SortedMap und implemetierende Klassen << interface >> Collection << interface >> Map public void clear(); public boolean containskey(Object key); public boolean containsValue(Object value); public Set entrySet(); public Object get(Object key); public boolean isEmpty(); public Set keySet(); public Object remove(Object key); public int size(); public Collection values(); HashMap public HashMap(); public Hashmap(Collection collection); public HashMap(int anfangskapazitaet); public HashMap(int anfangskapazitaet, int ladeFaktor); << interface >> SortedMap public Comparator comparator(); public Object firstKey(); public Object lastKey(); public SortedMap headmap(Object toKey); public SortedMap subMap(Object fromKey, Object toKey); public SortedMap tailMap(Object fromKey); Hashtable TreeMap public TreeMap(); public TreeMap(Map collection); public TreeMap(Comparator vergleich); public TreeMap(SortedMap collection); Abb.: Die Schnittstelle Map Eine Klasse, die Map implementiert, behandelt einen assoziativen Speicher. Dieser verbindet einen Schlüssel mit einem Wert. Die Klasse Hashtable erbt von Map. Map ist für die implementierenden Klassen AbstractMap, HashMap, Hashtable, 111 Algorithmen und Datenstrukturen RenderingHints, WeakHashMap und Attributes das, was die abstrakte Klasse Dictionary für die Klasse Hashtable ist. Die Schnittstelle SortedMap Eine Map kann mit Hilfe eines Kriteriums sortiert werden und nennt sich dann SortedMap. SortedMap erweitert direkt Map. Das Sortierkriterium wird mit einem speziellen Objekt, das sich Comparator nennt, gesetzt. Damit besitzt auch der assoziative Speicher über einen Iterator eine Reihenfolge. Nur die konkrete Klasse TreeMap implementiert bisher eine SortedMap. Die abstrakte Klasse AbstractMap implementiert die Schnittstelle Map. Die konkrete Klasse HashMap implementiert einen assoziativen Speicher, erweitert die Klasse AbstractMap und implementiert die Schnittstelle Map. Die konkrete Klasse TreeMap erweitert AbstractMap und implementiert SortedMap. Ein Objekt von TreeMap hält Elemente in einem Baum sortiert. Bsp. 65: Aufbau und Anwendung einer Hash-Tabelle import java.io.*; import java.util.*; public class HashTabTest { public static void main(String [ ] args) { Map map = new HashMap(); String eingabeZeile = null; BufferedReader eingabe = null; try { eingabe = new BufferedReader( new FileReader("eing.txt")); } catch (FileNotFoundException io) { System.out.println("Fehler beim Einlesen!"); } try { while ( (eingabeZeile = eingabe.readLine() ) != null) { StringTokenizer str = new StringTokenizer(eingabeZeile); if (eingabeZeile.equals("")) break; String key = str.nextToken(); String daten = str.nextToken(); System.out.println(key); map.put(key,daten); } } catch (IOException ioe) { System.out.println("Eingefangen in main()"); } try { eingabe.close(); } catch(IOException e) { System.out.println(e); } System.out.println("Uebersicht zur Hash-Tabelle"); System.out.println(map); 65 vgl. pr23300 112 Algorithmen und Datenstrukturen //h.printHashTabelle(); System.out.println("Abfragen bzw. Modifikationen"); // Wiederauffinden String eingabeKey = null; BufferedReader ein = new BufferedReader( new InputStreamReader(System.in)); System.out.println("Wiederauffinden von Elementen"); while (true) { try { System.out.print("Bitte Schluessel eingeben, ! bedeutet Ende: "); eingabeKey = ein.readLine(); // System.out.println(eingabeKey); if (eingabeKey.equals("!")) break; String eintr = (String) map.get(eingabeKey); if (eintr == null) System.out.println("Kein Eintrag!"); else { System.out.println(eintr); System.out.println("Soll dieser Eintrag geloescht werden? "); String antwort = ein.readLine(); // System.out.println(antwort); if ((antwort.equals("j")) || (antwort.equals("J"))) { // System.out.println("Eintrag wird entfernt!"); map.remove(eingabeKey); } } } catch(IOException ioe) { System.out.println(eingabeKey + " konnte nicht korrekt eingelesen werden!"); } } System.out.println(map); System.out.println("Sortierte Tabelle"); Map sortedMap = new TreeMap(map); System.out.println(sortedMap); } } 113 Algorithmen und Datenstrukturen 2.2.6 Algorithmen Die Wahl einer geeigneten Datenstruktur ist der erste Schritt. Im zweiten Schritt müssen die Algorithmen implementiert werden. Die Java Bibliothek hilft mit einigen Standardalgorithmen weiter. Dazu zählen Funktionen zum Sortieren und Suchen in Containern und das Füllen von Containern. Zum flexiblen Einsatz dieser Funktionen haben die Java-Entwickler die Klasse Collections 66 bereitgestellt. Collections bietet Algorithmen statischer Funktionen an, die als Parameter ein Collection Objekt erwarten. Objekte der Klasse Collections sind nicht sinnvoll, der einzige Konstruktor dieser Klasse ist deshalb private. Leider sind viele Algorithmen nur auf ListObjekte definiert 67, z.B. public static void shuffle(List<T> liste) // mischt die Elöemente von liste zufällig public static void shuffle(List liste) // würfelt die Werte einer Liste durcheinander Bsp. 68: import java.util.*; public class VectorShuffle { public static void main(String args[]) { Vector v = new Vector(); for (int i = 0; i < 10; i++) v.add(new Integer(i)); Collections.shuffle(v); System.out.println(v); } } public static void shuffle(List list, random rnd) // würfelt die Werte der Liste durcheinander und benutzt dabei den Random Generator rnd. Nur die Methoden min() und max() arbeiten auf allgemeinen Collection-Objekten. 2.2.5.1 Datenmanipulation Daten umdrehen. Die Methode reverse() dreht die Werte einer Liste um. Die Laufzeit ist linear zu der Anzahl der Elemente. public static void reverse(List l) // dreht die Elemente in der Liste um Listen füllen. Mit der fill()-Methode läßt sich eine Liste in linearer Zeit belegen. Nützlich ist dies, wenn eine Liste mit Werten initialisiert werden muß. public static void fill (List l, Object o) // füllt eine Liste mit dem Element o Daten zwischen Listen kopieren. Die Methode copy(List quelle, List ziel) kopiert alle Elemente von quelle in die Liste ziel und überschreibt dabei Elemente, die evtl. an dieser Stelle liegen. 66 Die Klasse Collections spielt eine ähnliche Rolle wie die Klasse Arrays Nutzt die Collection Klasse keine List Objekte, arbeitet sie mit Iterator Objekten, um allgemein zu bleiben 68 vgl. pr22122 67 114 Algorithmen und Datenstrukturen public static void copy(List quelle, List ziel) // kopiert Elemente von quelle nach ziel. Ist ziel zu klein, gibt es eine IndexOutOfBoundsException 2.2.5.2 Größter und kleinster Wert einer Collection Die Methoden min() und max() suchen das größte und kleinste Element einer Collection. Die Laufzeit ist linear zur Größe der Collection. Die Methoden machen keinen Unterschied, ob die Liste schon sortiert ist oder nicht. public static Object min(Collection c) // public static Object max(Collection c) /* Falls min() bzw. max() auf ein Collection-Objekt angewendet wird, erfolgt die Bestimmung des Minimums bzw. Maximums nach der Methode compareTo() der Comparable Schnittstelle. Byte, Character, Double, File, Float, Long, Short, String, Integer, BigInteger, ObjectStreamField, Date und Calendar haben diese Schnittstelle implementiert. Lassen sich die Daten nicht vergleichen, dann gibt es eine ClassCastException. */ public static Object min(Collection c, Comparator vergl) // public static Object max(Collection c, Comparator vergl) 2.2.5.3 Sortieren Die Collection Klasse bietet zwei sort() Methoden an, die die Elemente einer Liste stabil 69 sortieren. Die Methode sort() sortiert die Elemente in ihrer natürlichen Ordnung 70, z.B.: - Zahlen nach der Größe (13 < 40) - Zeichenketten alphanumerisch (Juergen < Robert < Ulli) Eine zweite überladene Form von sort() arbeitet mit einem speziellen Comparator Objekt, das zwei Objekte mit der Methode compare() vergleicht. public static void sort(List liste) // sortiert die Liste public static void sort(List liste,Comparator c) // sortiert die Liste mit dem Comparator c public static void sort(List<T> liste) // sortiert die Elemente der Liste mit Elementtyp T nach aufsteigender Größe Viele der Methoden der Klasse Collections , u.a.a sort() sind mit einem Comparator überladen. Die Methoden erfüllen den gleichen Zweck wie die Fassungen ohne Comparator. Zum Element-Vergleich benutzen sie aber das als Argument übergebene Comparator-Objekt anstelle der compareTo-Methode des Elementtyps. Comparator ist ein generisches Interface mit einer einzigen Methode compare. Diese Methode akzeptiert zwei Objekte des Elementtyps und liefert ein int-Ergebnis (wie compareTo()). 69 Stabile Sortieralgorithmen beachten die Reihenfolge von gleichen Elementen, z.B. beim Sortieren von Nachrichten in einem Email-Programm, zuerst nach dem Datum und anschließend nach dem Sender, soll die Liste innerhalb des Datum sortiert bleiben. 70 Zu sortierende Elemente müssen das Interface Comparable implemetieren bzw. implementiert haben. Die Klassen String, Integer, Double, Float ... sind bereits Comparable, ebenso Date, File und einige andere. 115 Algorithmen und Datenstrukturen Die Sortierfunktion arbeitet nur mit List-Objekten. „sort()“ gibt es aber auch in der Klasse Arrays. Bsp.: Das folgende Programm sortiert eine Reihe von Zeichenketten in aufsteigender Folge. Es nutzt die Methode Arrays.asList() zur Konstruktion einer Liste aus einem Array 71. import java.util.*; public class CollectionsSortDemo { public static void main(String args[]) { String feld[] = { "Regina","Angela","Michaela","Maria","Josepha", "Amalia","Vera","Valentina","Daniela","Saida", "Linda","Elisa" }; List l = Arrays.asList(feld); Collections.sort(l); System.out.println(l); } } Die Java Bibliothek bietet nicht viel zur Umwandlung von Feldern („Array“) in dynamische Datenstrukturen. Eine Ausnahme bildet die Hilfsklasse Arrays, die die Methode asList() anbietet. Die Behälterklassen ArrayList und LinkedList werden über asList() nicht unterstützt, d.h. Über asList() wird zwar eine interne Klasse ArrayList benutzt, die eine Erweiterung von AbstractList ist, aber nur das notwendigste implementiert. Sortieralgorithmus. Es handelt sich um einen optimierten „Merge-Sort“. Seine Laufzeit beträgt N ⋅ log( N ) . Die sort() Methode arbeitet mit der toArray() Funktion der Klasse List. Damit werden die Elemente der Liste in einem Feld (Array) abgelegt. Schließlich wird die sort() Methode der Klasse Arrays genutzt und mit einem ListIterator wieder in die Liste eingefügt. Daten in umgekehrter Reihenfolge sortieren. Das wird über ein spezielles Comparator-Objekt geregelt, das von Collections über die Methode reverseOrder() angefordert werden kann. Bsp. 72: import java.util.*; public class CollectionsReverseSortDemo { public static void main(String args[]) { Vector v = new Vector(); for (int i = 0; i < 10; i++) { v.add(new Double(Math.random())); } Comparator comparator = Collections.reverseOrder(); Collections.sort(v,comparator); System.out.println(v); } } Eine andere Möglichkeit für umgekehrt sortierte Listen besteht darin, erst die Liste mit sort() zu sortieren und anschließend mit reverse() umzudrehen. 71 72 Leider gibt es keinen Konstruktor für ArrayList, der einen Array mit Zeichenketten zuläßt. Vgl. pr22122 116 Algorithmen und Datenstrukturen 2.2.5.4 Suchen von Elementen Die Behälterklassen enthalten die Methode contains(), mit der sich Elemente suchen lassen. Für sortierte Listen gibt es eine wesentlich schnellere Suchmethode: binarySearch(): public static int binarySearch(List liste, Object key) // sucht ein Element in der Liste. Gibt die Position zurück oder ein Wert kleiner 0, // falls key nicht in der Liste ist. public static int binarySearch(List liste, Object key, Comparator c) // Sucht ein Element mit Hilfe des Comparator Objekts in der Liste. Gibt die Position zurück oder // einen Wert kleiner als 0, falls der key nicht in der Liste ist. public static int binarySearch(List<T> liste, T key) // sucht das Element key in der sortierten Liste t und liefert seinen Index zurück. // Bei mehreren Vorkommen von key wird der Index irgendeines t geliefert. Bsp. 73: Das folgende Programm sortiert (zufällig ermittelte) Daten und bestimmt Daten in Listen mit Hilfe der binären Suche. import java.util.*; public class ListSort { public static void main(String [] args) { final int GR = 20; // Verwenden einer natuerliche Ordnung List a = new ArrayList(); for (int i = 0; i < GR; i++) a.add(new VglClass((int)(Math.random() * 100))); Collections.sort(a); Object finde = a.get(GR / 2); int ort = Collections.binarySearch(a,finde); System.out.println("Ort von " + finde + " = " + ort); // Verwenden eines Comparator List b = new ArrayList(); // Bestimmt zufaellig Zeichenketten der Laenge 4 for (int i = 0; i < GR; i++) b.add(Felder.randString(4)); // Instanz fuer den Comparator AlphaVgl av = new AlphaVgl(); // Sortieren Collections.sort(b,av); // Binaere Suche finde = b.get(GR / 2); ort = Collections.binarySearch(b,finde,av); System.out.println(b); System.out.println("Ort von " + finde + " = " + ort); } } 73 Vgl. pr22122 117 Algorithmen und Datenstrukturen 2.2.6 Generics Einen Algorithmus, der von einem Datentyp unabhängig programmiert werden kann, nennt man generisch und die Möglichkeit in Java mit generischen Typen zu arbeiten Generics. 2.2.6.1 Sammlungsklassen Generische Typen werden zur Implementierung von Datenstrukturen wie Collections und Containern benötigt. Bei der Implementierung einer Collection stellt man fest, dass die Implementierung weitgehend unabhängig vom Typ der Elemente ist, die in der Collection abgelegt werden. Man möchte deshalb nur eine Implementierung der Collection zur Verfügung stellen, die dann für das Ablegen beliebiger Elementtypen verwendet werden kann. Traditionell (im nicht generischen Java) erreicht man das folgendermaßen: Die Collection Klassen (z.B. die Klassen aus dem J2SE 74 Collection Framework) vewalten Referenzen vom Typ Object. Da Object die Superklasse aller JavaKlassen ist, kann eine Collection Elemente beliebigen Typs enthalten. Ausgenommen sind lediglich die primitiven Typen, die nicht von Object abgeleitet sind. Das ist aber kein großes Problem, da es zu jedem primitiven Typ einen korrespondierenden Referenztyp gibt. Die Umwandlung eines primitiven Typs in einen korrespondierenden Referenztyp bezeichnet man als Boxing 75. Eine so implementierte Collection kann eine Mischung von Objekten verschiedenen Typs verwalten. Beim Herausholen unterschiedlicher Elemente aus einer Collection, weiß man allerdings niemals genau, von welchem Typ das betreffende Element ist. Deshalb muß man einen Laufzeit-Cast 76 machen, ehe man das Element verwenden kann. Java-Generics erlauben eine alternative Implementierungstechnik, bei der die Collections mit einem Element-Typ parametrisiert 77 werden und dann homogen sind, also Element desselben Typs enthalten. Das Einfügen eines "fremden Typs" wird zur Compile-Zeit bereits abgewiesen. Deshalb muß beim Herausholen aus der Collection nicht mehr überprüft werden, ob das gefundene Element vom gewünschten Typ ist. Bei einer parametrisierten Collection werden Typprüfungen bereits zur Compilezeit beim Einfügen der Element gemacht. Traditionelle Collections sind ein Beispiel für Weak Typing mit Typprüfungen zur Laufzeit. Parametrisierte Collections sind ein Beispiel für Strong Typing, bei dem Typeprüfungen bereits zur Compile-Zeit gemacht werden. Die Collections des traditionellen Collection Frameworks werden in der J2SE 1.5 durch parametrisierte Collections ersetzt. So kann eine LinkedList in J2SE 1.5 als LinkedList<String> oder LinkedList<Integer> verwendet werden. Die herkömmliche Verwendung als LinkedList ist aber weiterhin möglich. 74 Java 2 Standard Edition Ab Java 1.5 ist Autoboxing implementiert (automatische Konvertierung) 76 Ist dieser Laufzeit-Cast vom Typ Object-Referenz auf den Typ Integer-Referenz, dann kommt es, falls das Element kein Integer ist ui einer ClassCastException 77 vgl. 1.2.3.6.2 75 118 Algorithmen und Datenstrukturen Iterabe<E> Iterator<E> Collection<E> List<E> ArrayList<E> Queue<E> LinkedList<E> Map<K,V> Set<E> SortedSet<E> SortedMap <K,V> HashSet<E> ConcurrentMap <K,V> TreeMap<K,V> ConcurrentHash Map<K,V> TreeSet<E> Abb.: Klassenhierachie: Interfaces und konkrete Klassen im Paket java.util 119 HashMap <K,V> Algorithmen und Datenstrukturen 2.2.6.2 Implementierung von Java Generics Wie üblich, übersetzt der Java Compiler parametrisierte Methoden in Java Bytecode. 2.2.6.2.1 Übersetzung von Generics Ein Compiler hat prinzipiell zwei Möglichkeiten zur parametrisierten Typs bzw. einer parametrisierten Methode: - - Übersetzung eines Code-Spezialisierung. Dabei erzeugt der Compiler eine jeweils separate Repräsentation für jede einzelne Instanziierung eines parametrisierten Typs. Bspw. würde der Compiler mit dieser Technik Code für eine Liste von Strings und einer Liste von Integers erzeugen. Code-Sharing. Dabei erzeugt der Compiler nur eine einzige Repräsentation je parametisiertem Typ/Methode. Die verschiednen Instanziierungen des parametrisierten Typs werden auf diese eine Repräsentation abgebildet, wobei Typprüfungen und Typkonvertierungen eingefügt werden, wo immer das nötig ist. Code-Spezialisierung ist die in C++ verwendete Übersetzungstechnik. Ein C++Compiler generiert aus einem Template für jede Instanziierung unterschiedlichen Binärcode. Aus einem Listen-Template bspw. entsteht der Binärcode für mehrere Listen-Klassen. Code-Sharing ist die in Java verwendete Übersetzungstechnik. Das hat den Vortiel, dass tendenziell weniger Binärcode erzeugt wird. Es verhindert aber die Verwendung von primitiven Typen als Typargumente einer Instanziierung. In Java Generics erfolgt die Abbildung von verschiedenen Instanziierungen auf eine gemeinsamen Repräsentation der parametrisierten Typen/Methoden über eine Erasure. Die Übersetzung mit Hilfe des Typs Erasure kann man sich vorstellen wie eine Übersetzung von generischen Java in reguläres Java: von der Instanziierung eines parametrisierten Types bzw. einer parametrisierten Methode werden sämtliche Typparameter entfernt und in der Definition eines parametrisierten Typs bzw. einer parametrisierten Methode wird der Typparameter durch sein erstes Bound oder den Typ Object ersetzt, falls keine Bounds angegeben wurden. 2.2.6.2.2 Repräsentation von Generics im Laufzeitsystem Die Übersetzung per Type Erasure wurde bewusst von den Entwicklern der Java Generics als Übersetzungstechnik gewählt. Ziel des Designs der Java Generics ist die hundertprozentige Kompatibilität des aus Generics generierten Bytecode mit herkömmlichen Byte-Code. Es soll problemlos möglich sein, generischen mit nicht generischeM Code zu mischen. Es gibt deshalb nur wenige Spuren, die Generics in einer .class Datei dennoch hinterlassen: es werden sogenannte Signature-Attribute im Bytecode abgelegt. Sie enthalten statische Informationen über die Typparameter einer Klasse und Methoden. Diese Signature-Attribute werden von der virtuelle Maschine als Kommentar behandelt und nicht ausgewertet. Für die virtuelle Maschine gibt es keinerlei Unterschiede zwischen einem parametrisierten Typ bzw. einer perametrisierten Methode und einem regulären Tpy bzw. einer regulären Methode. 120 Algorithmen und Datenstrukturen 2.2.7 Spracherweiterung in Java zur Iteration Typischerweise wird in einem Programm über die Elemente eines Sammlungstyps iteriert oder über alle Elemente einer Reihung. Hierzu kennt Java eine Reihe von Schleifenkonstrukten. 2.2.7.1 Erweiterte for-Schleife Typischerweise wird in Programmen über die Elemente einer Klasse iteriert oder über alle Elemente eines Array (einer Reihung). Hierzu kennt Java verschiedene Schleifenkonstrukte. Bsp. 78: Iterieren über alle Elemente einer Reihe und Iterieren mit Hilfe eines Iteratorobjekts über alle Elemente eines Sammlungsobjekts. import java.util.List; import java.util.ArrayList; import java.util.Iterator; class AlteIteration { public static void main(String args []) { String [] ar = {"Brecht", "Goethe", "Shakespeare", "Schiller"}; List xs = new ArrayList(); for (int i = 0; i < ar.length; i++) { String s = ar[i]; xs.add(s); } for (Iterator it = xs.iterator(); it.hasNext();) { String s = (String) it.next(); System.out.println(s.toUpperCase()); } } } Mit Java 1.5 gibt es zusätzlich ein eigendes Schleifenkonstrukt, das bequem die Iteration über die Elemente einer Sammlung ausdrücken kann: for (Type identifier : expr) { // body } Zu lesen ist dieses Konstrukt als: "Für jedes identifier des Typs Type in expr führe body aus". Bsp. 79: import java.util.ArrayList; import java.util.Iterator; public class ForLoopTest { public static void main(String[] args) { double[] array = {2.5, 5.2, 7.9, 4.3, 2.0, 4.1, 7.3, 0.1, 2.6}; // Einfache Iteration vorwaerts durch die Schleife 78 79 pr22102 pr22102 121 Algorithmen und Datenstrukturen for(double d: array) { System.out.println(d); } System.out.println("---------------------"); // Das folgende arbeitet mit allem, das das Interface Iterable // implementiert, z.B mit Collections wie ArrayList ArrayList<Integer> list = new ArrayList<Integer>(); list.add(7); list.add(15); list.add(-67); for(Integer number : list) { System.out.println(number); } System.out.println("---------------------"); // Es unterstuetzt auch Autoboxing for(int item: list) { System.out.println(item); } System.out.println("---------------------"); } } Test: Abb.: 2.2.7.2 Das Interface Iterable Das erweiterte for möchte links vom Doppelpunkt ein Feld oder ein Objekt, das vom Typ Iterable ist. Diese Schnittstelle schreibt nur die Existenz einer Funktion iterator() vor, die einen java.lang.SimpleIterator liefert. Der konkrete SimpleIterator muß nur die Methoden hasNext() und next() implementieren, um das nächste Element in der Aufzählung zu geben und das Ende anzuzeigen. Ein SimpleIterator ist ein Iterator 80 ohne remove(). Bsp. 81: import java.util.Iterator; import java.util.StringTokenizer; class WordIterable implements Iterable, Iterator { private StringTokenizer st; public WordIterable( String s ) { 80 81 vgl. 2.2.8.1 pr22102 122 Algorithmen und Datenstrukturen st = new StringTokenizer( s ); } // Methode vom Iterable public Iterator iterator() { return this; } // Methoden vom Iterator public boolean hasNext() { return st.hasMoreTokens(); } public Object next() { return st.nextToken(); } public void remove() { } } public class WordIterableDemo { public static void main( String args[] ) { String s = "Am Anfang war das Wort - am Ende die Phrase. (Stanislaw Jerzy Lec)"; for ( Object word : new WordIterable(s) ) System.out.println( word ); } } Praktisch ist, dass java.util.Iterator seit Java 1.5 den SimpleIterator implementiert. Das folgende bekannte Programmierer-Idiom for (Iterator i = c.iterator(); i.hasNext(); ) { Typ o = (Typ) i.next(); } kann durch das erweiterte for erfolgreich abgekürzt werden: for (i : c) { Typ o = (Typ) I; } 123 Algorithmen und Datenstrukturen 2.2.8 Implementierung von Graphen-Algorithmen zur Berechnung kürzester Wege mit Behälterklassen Die folgende Abbildung zeigt einen gerichteten Graphen ohne Gewichte: k2 k1 k4 k3 k5 k7 k6 Abb.: Ein derartiger Graph wird im Speicher eines Rechners entweder als Adjazensliste oder Adjazensmatrix abgebildet. Die Darstellung des vorliegenden Graphen in einer Adjazenzliste zeigt die folgende Abbildung: k1 k2 k4 k2 k4 k5 k3 k1 k6 k4 k3 k5 k5 k6 k7 k7 k6 k7 k6 Abb.: Zur Implementierung derartiger Adjazenzlisten wird benötigt: - eine Liste mit den Knoten. Da auf die Knoten direkt zugegriffen werden soll, ist eine Implementierung einer Knotenliste über eine Hashmap erwünscht. Zu jedem Knoten der Knotenliste gehört einer Liste mit den Nachbarn des betrachteten Knoten. Jeder Eintrag in die Knotenliste wird durch die Datenstruktur Vertex beschrieben. Vertex enthält einen Anker zur Aufnahme einer verketteten Liste mit den benachbarten Knoten. Die Implementierung erfolgt über die Collection-Klasse LinkedList. 124 Algorithmen und Datenstrukturen 2.2.8.1 Die Datenstrukturen Graph, Vertex, Edge zur Implementierung von Graphenalgorithmen für die Berechnung kürzester Wege Repräsentation von Knoten 82 class Vertex { public String name; // Bezeichner des Knoten public List<Edge> adj; // Benachbarte Knoten public double dist; // Kosten public Vertex prev; // Vorgaengerknoten auf dem kuerzesten Pfad public int scratch; // Spez. Variable, die in den Alg. genutzt wird // Konstruktor public Vertex( String nm ) { name = nm; adj = new LinkedList<Edge>( ); reset( ); } // Methoden public void reset( ) { dist = Graph.INFINITY; prev = null; /* pos = null; */ scratch = 0; } } Über die Instanzvariable adj wird die Liste der benachbarten Knoten geführt, dist enthält die Kosten, path den Vorgängerknoten vom kürzsten Pfad. Identifiziert wird der Knoten durch einen Namen (Typ: String). Repräsentation von Kanten Die Kanten eines Graphen können Distanzen, Entfernungen, Gewichte, Kosten aufnehmen. Jede Kante eines Graphen wird beschrieben über den Zielknoten und das der Kante zugeordnete Gewicht. class Edge { public Vertex dest; // Zielknoten public double cost; // Gewicht // Konstruktor public Edge( Vertex d, double c ) { dest = d; cost = c; } } Die Klasse Graph zur Aufnahme von Algorithmen zur Berechnung kürzester Pfade public class Graph { public static final double INFINITY = Double.MAX_VALUE; protected Map<String,Vertex> vertexMap = new HashMap<String,Vertex>( ); /* * Hinzufuegen einer neuen Kante. */ public void addEdge( String sourceName, String destName, double cost ) { Vertex v = getVertex( sourceName ); Vertex w = getVertex( destName ); v.adj.add( new Edge( w, cost ) ); } /* * Routine zur Bearbeitung von nicht Erreichbarem bzw. Ausgabe der Kosten. * Aufruf einer rekursiven Methode zur Ausgabe kuerzester Pfade zum 82 vgl. pr22859 125 Algorithmen und Datenstrukturen * Zielknotem, nachdem ein kuezester_Pfad_Algorithmus gelaufen ist. */ public void printPath( String destName ) { Vertex w = (Vertex) vertexMap.get( destName ); if( w == null ) throw new NoSuchElementException( "Zielknoten wurde nicht gefunden" ); else if( w.dist == INFINITY ) System.out.println( destName + " ist unerreichbar" ); else { System.out.print( "(Kosten: " + w.dist + ") " ); printPath( w ); System.out.println( ); } } /* * Falls es den Knotennamen noch nicht gibt, * addiere ihn zur Map der Knoten. * Gib immer den Knoten zurueck. */ private Vertex getVertex( String vertexName ) { Vertex v = (Vertex) vertexMap.get( vertexName ); if( v == null ) { v = new Vertex( vertexName ); vertexMap.put( vertexName, v ); } return v; } /* * Rekursive Routine zur Ausgabe des kuerzesten Pfads zum Zielknoten, * nachdem der Algorithmus zum kuerzesten Pfad gelaufen ist. * Es ist bekannt, dass der Pfad existiert. */ private void printPath( Vertex dest ) { if( dest.prev != null ) { printPath( dest.prev ); System.out.print( " to " ); } System.out.print( dest.name ); } /* * Setzt den Graph auf die Ausgangsposition zur Bearbeitung * der Algorthmen fuer kuerzeste Pfade zurueck. */ private void clearAll( ) { for (Vertex v : vertexMap.values()) v.reset(); } /* * Graphenalgorithmen zur Berechnung kuerzester Pfade */ } 126 Algorithmen und Datenstrukturen 2.2.8.2 Kürzeste Pfade in gerichteten, ungewichteten Graphen. Lösungsbeschreibung. Die ungewichteten Graphen G: folgende Abbildung zeigt einen gerichteten, k2 k1 k4 k3 k5 k7 k6 Abb.: Ausgangspunkt ist ein Startknoten s (Eingabeparameter). Von diesem Knoten aus soll der kürzeste Pfad zu allen anderen Knoten gefunden werden. Es interessiert nur die Anzahl der Kanten, die in dem Pfad enthalten sind. Falls für s der Knoten k3 gewählt wurde, kann zunächst am Knoten k3 der Wert 0 eingetragen werden. Die „0“ wird am Knoten k3 vermerkt. k2 k1 k4 k3 k5 0 k7 k6 Abb.: Der Graph nach Markierung des Startknoten als erreichbar Danach werden alle Knoten aufgesucht, die „eine Einheit“ von s entfernt sind. Im vorliegenden Fall sind das k1 und k6. Dann werden die Knoten aufgesucht, die von s zwei Einheiten entfernt sind. Das geschieht über alle Nachfolger von k1 und k6. Im vorliegenden Fall sind es die Knoten k2 und k4. Aus den benachbarten Knoten von k2 und k4 erkennt man, dass k5 und k7 die kürzesten Pfadlängen von drei Knoten besitzen. Da alle Knoten nun bewertet sind ergibt sich folgenden Bild: k2 k1 1 2 k4 k3 0 k5 2 1 k6 k7 Abb.: Graph nach Ermitteln aller Knoten mit der kürzeszen Pfadlänge 2 127 Algorithmen und Datenstrukturen Die hier verwendete Strategie ist unter dem Namen „breadth-first search“ 83 bekannt. Die „Breitensuche zuerst“ berücksichtigt zunächst alle Knoten vom Startknoten aus, die am weitesten entfernt liegenden Knoten werden zuerst ausgerechnet. Übertragen der Lösungsbeschreibung in Quellcode. Zu Beginn sollte eine Tabelle mit folgenden Einträgen vorliegen: k k1 k2 k3 k4 k5 k6 k7 bekannt false false false false false false false dk ∞ ∞ 0 ∞ ∞ ∞ ∞ pk 0 0 0 0 0 0 0 Die Tabelle überwacht den Fortschritt beim Ablauf des Algorithmus und führt Buch über gewonnene Pfade. Für jeden Knoten werden 3 Angaben in der Tabelle verwaltet: - die Distanz dk des jeweiligen Knoten zu dem Startknoten s. Zu Beginn sind alle Knoten von s aus unerreichbar ( ∞ ). Ausgenommen ist natürlich s, dessen Pfadlänge ist 0 (k3). - Der Eintrag pk ist eine Variable für die Buchführung (und gibt den Vorgänger im Pfad an). - Der Eintrag unter „bekannt“ wird auf „true“ gesetzt, nachdem der zugehörige Knoten erreicht wurde. Zu Beginn wurden noch keine Knoten erreicht. Das führt zu der folgenden Knotenbeschreibung: class Vertex { public String public LinkedList public boolean public int public Vertex ..... } name; adj; bekannt; dist; path; // Name des Knoten // Benachbarte Knoten // Kosten // Vorheriger Knoten auf dem kuerzesten Pfad Die Grundlage des Algorithmus kann folgendermaßen (in Pseudocode) beschrieben werden: /* /* /* /* 1 2 3 4 */ */ */ */ /* 5 */ /* 6 */ /* 7 */ /* 8 */ /* 9 */ 83 void ungewichtet(Vertex s) { Vertex v, w; s.dist = 0; for (int aktDist = 0; aktDist < ANZAHL_KNOTEN; aktDist++) for each v if (!v.bekannt && v.dist == aktDist) { v.bekannt = true; for each w benachbart_zu v if (w.dist == INFINITY) { w.dist = aktDist + 1; w.path = v; } } } vgl. 5.2.2 128 Algorithmen und Datenstrukturen Der Algorithmus deklariert schrittweise je nach Distanz (d = 0, d = 1, d= 2 ) die Knoten als bekannt und setzt alle benachbarten Knoten von d w = ∞ auf die Distanz d w = d + 1. 2 Die Laufzeit des Algorithmus liegt bei O( V ) . 84 Die Ineffizienz kann beseitigt werden: d v ≠ ∞ . Einigen Knoten wurde dv = aktDist Es gibt nur zwei unbekannte Knotentypen mit zugeordnet, der Rest zeigt dv = aktDist + 1. Man braucht daher nicht die ganze Tabelle, wie es in Zeile 3 und Zeile 4 beschrieben ist, nach geeigneten Knoten zu durchsuchen. Am einfachsten ist es, die Knoten in zwei Schachteln einzuordnen. In die erste Schachtel kommen Knoten, für die gilt: dv = aktDist. In die zweite Schachtel kommen Knoten, für die gilt: dv = aktDist + 1. In Zeile 3 und Zeile 4 kann nun irgendein Knoten aus der ersten Schachtel herausgegriffen werden. In Zeile 9 kann w der zweiten Schachtel hinzugefügt werden. Wenn die äußere for-Schleife terminiert ist die erste Schachtel leer, und die zweite Schachtel kann nach der ersten Schachtel für den nächsten Durchgang übertragen werden. Durch Anwendung einer Schlange (Queue) kann das Verfahren verbessert werden. Am Anfang enthält diese Schlange nur Knoten mit Distanz aktDist. Benachbarte Knoten haben die Distanz aktDist + 1 und werden „hinten“ an die Schlange angefügt. Damit wird garantiert, daß zuerst alle Knoten mit Distanz aktDist bearbeitet werden. Der verbesserte Algorithmus kann in Pseudocode so formuliert werden: /* 1 */ /* 2 */ /* 3 */ /* /* /* /* 4 5 6 7 */ */ */ */ /* 8 */ /* 9 */ /*10 */ void ungewichtet(Vertex s) { Queue q; Vertex v, w; q = new Queue(); q.enqueue(s); s.dist = 0; while (!q.isEmpty()) { v = q.dequeue(); v.bekannt = true; // Wird eigentlich nicht mehr benoetigt for each w benachbart_zu v if (w.dist == INFINITY) { w.dist = v.dist + 1; w.path = v; q.enqueue(w); } } } Die folgende Tabelle zeigt, wie sich die Daten der Tabelle während der Ausführung des Algorithmus ändern: Anfangszustand k bekannt dk k1 false ∞ k2 false ∞ k3 false 0 k4 false ∞ k5 false ∞ k6 false ∞ k7 false ∞ Q: k3 84 pk 0 0 0 0 0 0 0 k3 aus der Schlange bekannt dk pk false 1 k3 false 0 ∞ true 0 0 false 0 ∞ false 0 ∞ false 1 k3 false 0 ∞ Q: k1, k6 k1 aus der Schlange bekannt dk pk true 1 k3 false 2 k1 true 0 0 false 2 k1 false 0 ∞ false 1 k3 false 0 ∞ Q: k6, k2, k4 wegen der beiden verschachtelten for-Schleifen 129 k6 aus der Schlange bekannt dk pk true 1 k3 false 2 k1 true 0 0 false 2 k1 false 0 ∞ true 1 k3 false 0 ∞ Q: k2, k4 Algorithmen und Datenstrukturen k2 aus der Schlange k bekannt dk k1 true 1 k2 true 2 k3 true 0 k4 false 2 k5 false 3 k6 true 1 k7 false ∞ Q: k4, k5 pk k3 k1 0 k1 k2 k3 0 k4 aus der Schlange bekannt dk pk true 1 k3 true 2 k1 true 0 0 true 2 k1 false 3 k2 true 1 k3 false 3 k4 Q: k5, k7 k5 aus der Schlange bekannt dk pk true 1 k3 true 2 k1 true 0 0 true 2 k1 true 3 k2 true 1 k3 false 3 k4 Q: k7 K7 aus der Schlange bekannt dk pk true 1 k3 true 2 k1 true 0 0 true 2 k1 true 3 k2 true 1 k3 true 3 k4 Q: leer Abb.:Veränderung der Daten während der Ausführung des Algorithmus zum kürzesten Pfad Implementierung 85. Die Klasse Graph implementiert die Methode unweighted(). Die Schlange in dieser Liste wird über eine LinkedList mit den Methoden removeFirst() und addLast() simuliert. /* * Single-source unweighted shortest-path algorithm. */ public void unweighted( String startName ) { clearAll( ); Vertex start = (Vertex) vertexMap.get( startName ); if( start == null ) throw new NoSuchElementException( "Startknoten nicht gefunden" ); LinkedList q = new LinkedList( ); q.addLast( start ); start.dist = 0; while( !q.isEmpty( ) ) { Vertex v = (Vertex) q.removeFirst( ); for (Edge e : v.adj) { Vertex w = e.dest; if( w.dist == INFINITY ) { w.dist = v.dist + 1; w.prev = v; q.addLast( w ); } } } } 85 vgl.: pr22859 130 Algorithmen und Datenstrukturen 2.2.8.3 Berechnung der kürzesten Pfadlängen in gewichteten Graphen (Algorithmus von Dijkstra) Gegeben ist ein gerichteter Graph G mit Knotenmenge V und Kantenmenge E. Jede Kante e kat eine nichtnegative Länge, Außerdem ist ein Knoten s (Standort) gegeben. Gesucht ist der kürzeste Weg von s nach v für jeden Knoten v ∈ V des Graphen. Vorausgesetzt ist, dass jeder Knoten v ∈ V durch wenigstens einen Weg von s aus erreichbar ist. Für den kürzesten Weg soll die Länge ermittelt werden. Lösungsbeschreibung. Die Lösung stützt sich auf die Berechnung der kürzesten Pfadlängen in ungewichteten Graphen 86 ab. Im Algorithmus von Dijkstra werden auch die Daten über „bekannt“, dv (kürzeste Pfadlänge) und pv (letzter Knoten, der eine Veränderung von dv verursacht hat) verwaltet. Es wird eine Menge S von Knoten betrachtet und schrittweise vergrößert, für die der kürzeste Weg von s aus bereits bekannt ist. Jedem Knoten v ∈ V wird ein Distanz d(v) zugeordnet. Anfangs ist d(s) = 0 und für alle von s verschiedenen Knoten v ∈ V ist d v = ∞ , und S ist leer. Dann wird S nach dem Prinzip "Knoten mit kürzester Distanz von s zuerst" schrittweise folgendermaßen vergrößert, bis S alle Knoten V des Graphen enthält: 1. Wähle Knoten v ∈ V S mit minimaler Distanz 2. Nimm v zu S hinzu 3. Für jede Kante vw von einem Knoten v zu einem Knoten w ∉ S , ersetze d(w) durch min({d (v), d (v) + c(v, w)}) Der folgende Graph 2 k2 k1 4 1 3 10 2 2 k4 k3 5 8 k5 4 6 k7 k6 1 Abb.: Graph nach Ermitteln aller Knoten mit der kürzeszen Pfadlänge 2 mit der Knotenbeschreibung class Vertex { .... public LinkedList public boolean public DistType 87 public Vertex ... } 86 87 adj; // Benachbarte Knoten bekannt; // dist; // Kosten path; // Vorheriger Knoten auf dem kuerzesten Pfad vgl. 1. DistType ist wahrscheinlich int 131 Algorithmen und Datenstrukturen führt zu der folgende Initialisierung: k k1 k2 k3 k4 k5 k6 k7 bekannt false false false false false false false dk 0 ∞ ∞ ∞ ∞ ∞ ∞ pk null null null null null null null Abb.: Anfangszustand der Tabelle mit den Daten für den Algorithmus von Dijkstra Der erste Knoten (Start) ist der Knoten k1 mit Pfadlänge 0. Nachdem k1 bekannt ist, ergibt sich folgendes Bild: k k1 k2 k3 k4 k5 k6 k7 bekannt true false false false false false false dk 0 2 ∞ 1 ∞ ∞ ∞ pk null k1 null k1 null null null Abb.: Zustand der Tabelle nach „k1 ist bekannt“ „k1“ besitzt die Nachbarknoten: k2 und k4. „k4“ wird gewählt und als bekannt markiert. Die Knoten k3, k5, k6 und k7 sind jetzt die benachbarten Knoten. k k1 k2 k3 k4 k5 k6 k7 bekannt true false false true false false false dk 0 2 3 1 3 9 5 pk null k1 k4 k1 k4 k4 k4 Abb.: Zustand der Tabelle nach „k4 ist bekannt“ „k2“ wird gewählt. „k4“ ist benachbart, aber schon bekannt. „k5“ ist ebenfalls benachbart, wir aber nicht ausgerichtet, da die Kosten von „k2“ aus 2 +10 = 12 sind und ein Pfad der Länge 3 schon bekannt ist k k1 k2 k3 k4 k5 k6 k7 bekannt true true false true false false false dk 0 2 3 1 3 9 5 pk null k1 k4 k1 k4 k4 k4 Abb.: Zustand der Tabelle nach „k2 ist bekannt“ 132 Algorithmen und Datenstrukturen Der nächste ausgewählte Knoten ist „k5“ (ohne Ausrichtungen), danach wird k3 gewählt. Die Wahl von „k3“ bewirkt die Ausrichtung von „k6“ k k1 k2 k3 k4 k5 k6 k7 bekannt true true true true true false false dk 0 2 3 1 3 8 5 pk null k1 k4 k1 k4 k3 k4 Abb.: Zustand der Tabelle „k5 ist bekannt“ und (anschließend) „k3 ist bekannt“. „k7“ wird gewählt. Daraus resultiert folgende Tabelle: k k1 k2 k3 k4 k5 k6 k7 bekannt true true true true true false true dk 0 2 3 1 3 6 5 pk null k1 k4 k1 k4 k7 k4 Abb.: Zustand der Tabelle „k7 ist bekannt“. Schließlich bleibt nur noch k6 übrig. Das ergibt dann die folgende Abschlußtabelle: k k1 k2 k3 k4 k5 k6 k7 bekannt true true true true true true true dk 0 2 3 1 3 6 5 pk null k1 k4 k1 k4 k7 k4 Abb.: Zustand der Tabelle nach „k6 ist bekannt“. Der Algorithmus, der diese Tabellen folgendermaßen beschrieben werden: berechnet, kann void dijkstra(Vertex s) { Vertex v, w; /* 1 */ s.dist = 0; /* 2 */ for(; ;) { /* 3 */ v = kleinster_unbekannter_Distanzknoten; /* 4 */ if (v == null) /* 5 */ break; /* 6 */ v.bekannt = true; /* 7 */ for each w benachbart_zu v /* 8 */ if (!w.bekannt) /* 9 */ if (v.dist + cvw < w.dist) { /* 10 */ w.dist = v.dist + cvw; /* 11 */ w.pfad = v; } 133 (in Pseudocode) Algorithmen und Datenstrukturen } } Die Laufzeit des Algorithmus resultiert aus dem Aufsuchen aller Knoten (in den beiden for-Schleifen) und im Aufsuchen der Kanten (c(vw)) (in der inneren forSchleife): O(|E| + |V|2) = O(|V|2). Ein Problem des vorstehenden Agorithmus ist das Durchsuchen der Knotenmenge nach der kleinsten Distanz 88. Man kann das wiederholte Bestimmen der kleinsten Distanz einer prioritätsgesteuerten Warteschlange übertragen. Der Leistungsaufwand beträgt dann O(|E| log(|V)+|V| log(|V|)). Der Algorithmus (in Pseudocode) könnte so aussehen: /* 1 */ for_all v ∈ V do d (v ) = ∞ /* 2 */ d ( s ) = 0 ; S = 0 /* 3 */ pq = new PriorityQueue(); // Vorrangwarteschlange für Knoten in V /* 4 */ while pq ≠ 0 do /* pq = V S */ pq.delete _ min() /* 6 */ S = S ∪ {v} /* 7 */ for _ all (v, w) ∈ E do /* 8 */ if d (v) + c(v, w) < d ( w) pq.decrease _ key( w, d (v) + c(v, w)) /* 9 */ Entferne (v, w) aus E /* 5 */ /*10*/ end while prioritätsgesteuerte Warteschlange: Heaps sind eine mögliche Implementation für Priority Queues. Ein Heap mit N Schlüsseln erlaubt das Einfügen eines neuen Elements und das Entfernen des Minimums in O(log N ) Schritten. Da das Minimum stets am Anfang des Heap steht, kann der Zugriff auf das kleinste Element stets in konstanter Zeit ausgeführt werden. In Java gibt es seit der Version 1.5 die Klasse PriorityQueue, die sich auf einen Binary Heap abstützt. public class PriorityQueue<E 89> extends AbstractQueue implements Serializable // Konstruktoren PriorityQueue() PriorityQueue(Collection<? extends E> c) PriorirityQueue(int intCapacity) // Methoden public boolean add(E o) // fügt ein spezifiziertes Element in die Schlange ein public void clear() // entfernt alle Elemente aus der Schlange public Comparator<? super E> comparator() public Iterator<E> iterator() public boolean offer(E o) public boolean peek() public E poll() // entfernt und gibt das Element zurück, das am Kopf der Schlange sich befindet public boolean remove(Object o) // entfernt ein Element aus der Schlange public int size() 88 89 v = kleinster_unbekannter_Distanzknoten Typ des Elements, das in die Queue aufgenommen wurde 134 Algorithmen und Datenstrukturen Geerbt wird u.a. die Methode isEmpty() der Klasse Collection. In der Priority-Queue werden für den Algorithmus von Dijkstra Datensätze von folgendem Typ abgelegt: class Path implements Comparable { public Vertex dest; // w public double cost; // d(w) // Konstruktor public Path( Vertex d, double c ) { dest = d; cost = c; } // Methode des Comparable-Interface public int compareTo( Object rhs ) { double otherCost = ((Path)rhs).cost; return cost < otherCost ? -1 : cost > otherCost ? 1 : 0; } } Implementierung. 90 /* * Kuerzster Pfad Algorihmus mit Gewichten. */ public void dijkstra( String startName ) { PriorityQueue pq = new PriorityQueue(); Vertex start = (Vertex) vertexMap.get( startName ); if( start == null ) throw new NoSuchElementException( "Start vertex not found" ); clearAll( ); pq.add( new Path( start, 0 ) ); start.dist = 0; int nodesSeen = 0; while( !pq.isEmpty( ) && nodesSeen < vertexMap.size( ) ) { Path vrec = (Path) pq.poll( ); Vertex v = vrec.dest; if( v.scratch != 0 ) // schon bearbeited v continue; v.scratch = 1; nodesSeen++; for( Iterator itr = v.adj.iterator( ); itr.hasNext( ); ) { Edge e = (Edge) itr.next( ); Vertex w = e.dest; double cvw = e.cost; if( cvw < 0 ) throw new GraphException( "Graph hat negativ gewichtete Kanten" ); if( w.dist > v.dist + cvw ) { w.dist = v.dist +cvw; w.prev = v; pq.add( new Path( w, w.dist ) ); } } } } 90 vgl. pr22859 135 Algorithmen und Datenstrukturen 2.2.8.4 Berechnung der kürzesten Pfadlängen in gewichteten Graphen mit negativen Kosten Falls ein Graph Kanten mit negativen Kosten enthält, arbeitet der DijkstraAlgorithmus nicht korrekt. Das Problem ist, falls ein Knoten u als bekannt dekariert ist, die Möglichkeit besteht, dass es einen Weg zurück nach u von einem Knoten v mit negativem Resultat gibt. Eine mögliche, aber umständliche Lösung ist: Addition einer Konstanten Δ zu jedem Kantengewicht. Die Konstante wird so groß gewählt, dass keine negativen Kanten nach der Addition vorliegen. Besser ist der folgende Algorithmus (in Pseudocode): void negativ_gewichtet(Vertex s) { Queue q; Vertex v, w; /* 1*/ q = new Queue(); // /* 2*/ q.enqueue(s); // Einreihen des Startknoten s /* 3*/ while (!q.isEmpty()) { /* 4 */ v = dequeue(); /* 5 */ for each w adjazent to v /* 6 */ if (v.dist + cvw < w.dist) { // Update w /* 7 */ w.dist = v.dist + cvw; /* 8 */ w.path = v; /* 9 */ if (w ist nicht in q) /* 10*/ q.enqueue(w); } } } Komplexität. Jeder Knoten kann etwa |V| mal aus der Warteschlange entnommen werden, die Laufzeit ist somit O( | E | ⋅ | V | ) (Anstieg gegenüber dem Djikstra Algorithmus), falls Adjazenslisten benutzt werden. Falls negative "Kosten-Zyklen" vorliegen, dann gelangt der Algorithmus in eine Endlosschleife. Implementierung 91 public void negative( String startName ) { clearAll( ); Vertex start = (Vertex) vertexMap.get( startName ); if( start == null ) throw new NoSuchElementException( "Startknoten wurde nicht gefundem"); LinkedList<Vertex> q = new LinkedList<Vertex>( ); q.addLast( start ); start.dist = 0; start.scratch++; while( !q.isEmpty( ) ) { Vertex v = (Vertex) q.removeFirst( ); if( v.scratch++ > 2 * vertexMap.size( ) ) throw new GraphException( "Negative Zyklen entdeckt" ); for (Edge e : v.adj) { Vertex w = e.dest; double cvw = e.cost; if( w.dist > v.dist + cvw ) 91 vgl. pr22859 136 Algorithmen und Datenstrukturen { w.dist = v.dist + cvw; w.prev = v; // Einreihen nur, wenn noch nicht in der Schlange if( w.scratch++ % 2 == 0 ) q.addLast( w ); else w.scratch--; // undo the enqueue increment } } } } 2.2.8.5 Berechnung der kürzesten Pfadlängen in gewichteten, azyklischen Graphen Falls bekannt ist, dass der Graph azyklisch ist, kann der Dijkstra-Algorithmus verbessert werden: Die Knoten des Graphen werden in topologischer Reihenfolge (partielle Ordnung 92) ausgewählt. Die Auswahl der Knoten in topologischer Folge garantiert: die Distanz dv kann nicht weiter erniedrigt werden. /* Kuezester Pfad fuer azyklische Graphen mit negativ Gewichten. */ public void acyclic( String startName ) { Vertex start = (Vertex) vertexMap.get( startName ); if( start == null ) throw new NoSuchElementException( "Startknoten wurde nicht gefunden" ); clearAll( ); LinkedList<Vertex> q = new LinkedList<Vertex>( ); start.dist = 0; // Berechne indegrees Collection vertexSet = vertexMap.values( ); for( Iterator vsitr = vertexSet.iterator( ); vsitr.hasNext( ); ) { Vertex v = (Vertex) vsitr.next( ); for( Iterator witr = v.adj.iterator( ); witr.hasNext( ); ) ( (Edge) witr.next( ) ).dest.scratch++; } // Einordnen der Knoten mit indegree zero in die Schlange for( Iterator vsitr = vertexSet.iterator( ); vsitr.hasNext( ); ) { Vertex v = (Vertex) vsitr.next( ); if( v.scratch == 0 ) q.addLast( v ); } int iterations; for( iterations = 0; !q.isEmpty( ); iterations++ ) { Vertex v = (Vertex) q.removeFirst( ); for (Edge e : v.adj) { Vertex w = e.dest; double cvw = e.cost; if( --w.scratch == 0 ) q.addLast( w ); if( v.dist == INFINITY ) continue; if( w.dist > v.dist + cvw ) { w.dist = v.dist + cvw; w.prev = v; } } } if( iterations != vertexMap.size( ) ) throw new GraphException( "Graph has a cycle!" ); } } 92 vgl. 1.2.2.2 137 Algorithmen und Datenstrukturen 3. Algorithmen 3.1 Ausgesuchte algorithmische Probleme 3.1.1 Spezielle Sortieralgorithmen Sortieren bedeutet: Anordnen einer gegebenen Menge von Datenelementen in einer nach diesen Elementen bestimmten Ordnung 93. Danach sind Suchvorgänge wesentlich vereinfacht. Da es nur wenige Programmierprobleme gibt, die ohne Sortieren auskommen, ist die Vielfalt der dafür vorhandenen Algorithmen fast unüberschaubar. Alle verfolgen den gleichen Zweck, viele sind in gewisser Hinsicht optimal, und die meisten Algorithmen haben unter gewissen Bedingungen auch Vorteile gegenüber anderen. Eine Leistungsanalyse der Algorithmen kann diese Vorteile herausstellen. Selbstverständlich hängt auch beim Sortieren die Wahl des Algorithmus von der Struktur der zu bearbeitenden Daten ab. Die Sortiermethoden teilen sich hier grundsätzlich bereits in zwei Gruppen: - Sortieren von Feldern (internes Sortieren) Felder befinden sich auf direkt zugreifbaren, internen Speicherbereichen. - Sortieren von (sequentiellen) Dateien (externes Sortieren). Dateien sind auf externen Speichern (Bänder, Platten) untergebracht. Daten liegen hier im Format eines sequentiellen File vor. Dadurch ist zu jeder Zeit nur eine Komponente im direkten Zugriff. Diese Einschränkungen gegenüber Feldstrukturen bedeutet, daß andere Techniken zum Sortieren herangezogen werden müssen. 3.1.1.1 Interne Sortierverfahren 3.1.1.1.1 Quicksort Beschreibung. Beim Quicksort-Verfahren wird in jedem Schritt ein Element x der zu sortierenden Folge als Pivot-Element ausgewählt. Dann wird die zu sortierende Folge so umgeordnet, dass eine Teilfolge links von x entsteht, in die alle Werte der Elemente kommen, die nicht größer als x sind. Rechts von x entsteht eine Teilfolge, in der alle Werte der Elemente kommen, die größer sind als das Pivot-Element x. Diese Teilfolgen werden dann selbst wieder nach dem gleichen Verfahren rekursiv zerlegt und umsortiert. Dies geschieht so lange, bis die Teilfolgen die Länge 1 besitzen und damit bereits sortiert sind, so dass man am Ende eine vollständig sortierte Folge enthält. 93 1.2.2.2 138 Algorithmen und Datenstrukturen Abb.: Implementierung. void quicksort(char array[], int min, int max) { int left = min, right = max; // reads the value of the cell in the middle char middle = array[(left + right) / 2]; do { // find first element >= element in the middle while (array[left] < middle) left++; // find last element <= element in the middle while (array[right] > middle) right--; // swap these elements if (left < right) swap(array, left, right); if (left <= right) } left++; // go to the right--; // next elements } // continue as long as we meet in the middle } while (left <= right); if (min < right) // separate the array quicksort(array, min, right); // into two parts and continue sorting if (left < max) // as long there is a part which quicksort(array, left, max); // has more than one cell } 139 Algorithmen und Datenstrukturen ⎛N⎞ Aufwand. Maximal werden zum Sotieren des Felds (Array) der Länge N ⎜⎜ ⎟⎟ ⎝2⎠ Vergleiche benötigt. Besonders ungünstig ist eine bereits sortierte Liste. Wird der Quicksort auf eine solche Liste angesetzt und ist die Wahl des Pivot-Elements auf das erste bzw. letze Element gefallen, dann läuft in diesem Fall das „Divide and Conquer“-Verfahren komplett ins Leere 94. In diesem Fall benötigt der Quicksort N ⎛N⎞ n − i = ⎜⎜ ⎟⎟ Vergleiche. ∑ i =1 ⎝2⎠ Durchschnittlich benötigt der Quicksort zum Sortieren eines Felds der Länge N 2 ⋅ ln(2) N ⋅ log( N ) + O( N ) Vergleiche. Entscheidend für die Laufzeit vom Quicksort ist hierbei die gute Wahl des Pivotelements: - Fällt die Wahl auf das letzte Element, dann ist das schlecht bei vorsortierten Arrays. - Bei einer zufälligen Wahl liegt besseres Verhalten vor bei vorsortierten Arrays. Nachteilig ist der zusätzliche Aufwand für die Randomisierung. - Meistens entscheidet man sich für die Wahl des Median: Das mittlere Element des ersten, mittleren und letzten Elements des Array. 3.1.1.1.2 Heap-Sort Beschreibung. Der Algorithmus zum Heap-Sort untergliedert sich in zwei Phasen: - In der ersten Phase wird aus der unsortierten Folge von N Elementen ein Heap aufgebaut. - In der zweiten Phase wird der Heap ausgegeben, d.h. ihm wird jeweils das größte Element entnommen (das ja an der Wurzel steht). Dieses Element wird in die zu sortierende Folge aufgenommen und die Heap-Eigenschaften werden anschließend wieder hergestellt. Implementierung 95. // import java.io.*; public class HeapSort { private static void durchdringeRunter(Comparable [] a, int i, int n) { int kind ; Comparable tmp; for (tmp = a[i]; (2* i + 1) < n; i = kind) { kind = 2 * i + 1; if (kind != n - 1 && a[kind].compareTo(a[kind+1]) < 0) kind++; System.out.println(i + ", " + kind + ", " + a[kind]); if (tmp.compareTo(a[kind]) < 0) a[i] = a[kind]; else break; } a[i] = tmp; } public static void heapsort(Comparable [] a) { for (int i = a.length / 2; i >= 0; i--) 94 95 Eine der entstehenden Teilfoge ist leer, die andere enthält alle restlichen Elemente. pr13228 140 Algorithmen und Datenstrukturen durchdringeRunter(a, i, a.length); for (int i = a.length - 1; i > 0; i--) { Comparable tmp = a[0]; a[0] = a[i]; a[i] = tmp; durchdringeRunter(a,0,i); } } public static void main(String[ ] args) { // InputStreamReader isr = new InputStreamReader(System.in); // BufferedReader ein = new BufferedReader(isr); int [] x = { 150, 80, 40, 30, 10, 70, 110, 100, 20, 90, 60, 50, 120, 140, 130 }; Comparable [] a = new Comparable[x.length]; for (int i = 0; i < x.length; i++) { a[i] = new Integer(x[i]); } HeapSort.heapsort(a); System.out.println("Sortierte Ausgabe: "); for (int i = 0; i < a.length; i++) System.out.print(a[i].toString() + ", " ); System.out.println(); } } Leistungsaufwand. Mit dem Heap-Sort kann ein Feld der Länge N mit höchstens 2 ⋅ N ⋅ log( N ) + O( N ) vielen Vergleichen sortiert werden. Ein Heap mit l Stufen (Level) verfügt höchstens über 2l-1 Knoten. Beim Heap-Sort ist die Anzahl der Vergleiche kleiner als die Anzahl der Vergleiche zum Erzeugen eines Heap für N beliebige Elemente addiert mit der Summe der Vergleiche bei allen „Löschungen des Größtwerts“. Anzahl der Vergleiche zum Erzeugen eines Heap für N beliebige Elemente: l −1 ≤ 2 l −1 ⋅ 0 + 2 l − 2 ⋅ 2 ⋅ 1 + ... + 2 ⋅ 2 ⋅ (l − 2) + 1 ⋅ 2 ⋅ (l − 1) = ∑ 2 i ⋅ 2 ⋅ (l − 1 − i ) = 2 ⋅ 2 l − 2 ⋅ l + 2 i =0 Anzahl der Vergleiche zum Löschen des Maximums: Spätestens nach dem Löschen von 2l-1 Elementen nimmt die Anzahl der Levels des Heap um 1 ab, nach weiteren 2l-2 Elementen wieder um 1, usw. Damit gilt für die Anzahl der Vergleiche l −1 ≤ 2 l −1 ⋅ 2 ⋅ (l − 1) + 2 l − 2 ⋅ 2 ⋅ (l − 2) + ... + 2 ⋅ (2 ⋅ 1) = 2 ⋅ ∑ i ⋅ 2 i = 2 ⋅ ((l − 2) ⋅ 2 l + 2) . i =1 Für die Anzahl der Vergleiche beim Heap-Sort ergibt sich damit: ≤ 2 ⋅ 2 l − 2 ⋅ l + 2 + 2 ⋅ ((l − 2) ⋅ 2 l + 2) = 2 ⋅ l ⋅ 2 l − 2 ⋅ l + 6 Da der Heap-Sort auf einem N Elemente umfassenden Array ausgeführt wird, ergibt sich die Höhe l zu ⎡log 2 ( N + 1) ⎤ . die Anzahl der Vergleiche ist dann beim Heap-Sort bestimmt durch: 2 ⋅ N ⋅ log 2 ( N ) + O( N ) 141 Algorithmen und Datenstrukturen 3.1.1.1.3 Sortieren durch Mischen 1. Einführung Aus 2 (2-Weg-Mischen) oder mehr (n-Weg-Mischen) bereits sortiert vorliegenden Teillisten ist durch geeignetes Zusammenfügen eine einzige sortierte Teilliste zu erzeugen. Auf diese Weise sollen aus kleinen Teillisten (zu Beginn: Länge = 1) immer größere produziert werden, bis schließlich nur noch eine einzige sortierte Liste übrig bleibt. 2. Verschmelzen von Feldern Kern dieses Mischverfahrens ist das wiederholte Verschmelzen sortierter Teillisten. Bsp.: 17 11 Vergleiche: 17 - 11 23 37 68 45 78 67 17 - 37 23 - 37 37 - 68 45 - 68 67 - 68 Abb.: Der soeben beschriebene Mischungsvorgang findet häufig auch bei Dateien Anwendung 96. 3. 2-Wege-Mischsortieren Eine Folge von Schlüsseln wird sortiert, indem bereits sortiert vorliegende Teilfolgen zu immer längeren Teilfolgen verschmolzen werden. Zu Beginn ist jeder Schlüssel eine sortierte Teilfolge. In einem Durchgang werden jeweils zwei benachbarte Teilfolgen zu einer Folge verschmolzen. Ist die Anzahl der Schlüssel eine Potenz von 2, dann ist das paarweise Zusammenmischen, ohne daß eine Teilfolge übrig bleibt, immer gewährleistet, z.B.: 27 18 33 55 68 12 16 08 87 95 63 37 45 52 11 96 18 27 33 55 12 68 08 16 87 95 37 63 45 52 11 18 27 33 55 08 12 16 68 37 63 87 95 11 16 45 08 12 16 18 27 33 55 68 11 19 37 45 52 63 87 08 11 12 16 18 19 27 33 37 45 52 55 63 68 87 vgl. Sequential Update Problem 142 Algorithmen und Datenstrukturen 19 19 52 95 95 Bei jedem Durchgang verdoppelt sich die Länge der Teilfolgen. Falls die Anzahl der Schlüssel keine Zweierpotenz ist, bleibt am Ende eines Durchgangs eine Teilfolge übrig, z.B.: 27 18 33 55 68 12 16 8 87 95 63 18 27 33 55 12 68 8 16 87 95 63 18 27 33 55 8 12 16 68 63 87 95 8 12 16 18 27 33 55 68 63 87 95 8 12 16 18 27 33 55 63 68 87 95 Vollständig ist die Schlüsselfolge sortiert, falls in einem Durchgang nur noch zwei Teilfolgen verschmelzen. Leistungsanalyse. Durch das Umspeichern geht jeder Schlüssel in jedem Durchlauf in eine Elementaroperation ein. Neben dem Transport findet auch ein Vergleich statt (mit Ausnahme der Restliste). Da es bei N = 2n Schlüsseln n = ldN Durchläufe gibt, ist der Gesamtaufwand: Z = NldN Der Speicheraufwand ist: S = 2N 4. Rekursives Mischsortieren Das Prinzip des 2-Wege-Mischsortierverfahrens beruht in der Aufteilung. Eine Teilfolge ist einfacher zu sortieren als die vollständige Folge. Diese Folge wird deshalb zunächst einmal geteilt, da die beiden Hälften einfacher durch das Mischsortieren zu behandeln sind. Die sortierte Folge ergibt sich dann durch Verschmelzen der beiden sortierten Teilfolgen. Nutzt man dieses Prinzip vollständig aus, dann ist das Teilen schließlich so weit durchzuführen bis Teilfolgen vorliegen, die bereits sortiert sind. Eine Folge, die nur aus einem Schlüssel besteht ist immer sortiert und besimmt damit eindeutig das Ende des Teilungsprozesses. Das Mischsortieren ist damit eindeutig durch ein rekursives Verfahren lösbar. // Rekursives Mischsortieren in C++ template <class T> void mische(const T* a, int na, const T* b, int nb, T* c) { int ia = 0, ib = 0, ic = 0; while (ia < na && ib < nb) c[ic++] = (a[ia] < b[ib] ? a[ia++] : b[ib++]); while(ia < na) c[ic++] = a[ia++]; while(ib < nb) c[ic++] = b[ib++]; } // Die vorliegende Funktion dient als Basis fuer ein einfaches und // schnelles Sortierverfahren. Nachteilig: Ein zusaetzliches "Array" // ist noetig template <class T> void mischSort(T* a, int n) { if (n < 2) return; int nLinks = n / 2, nRechts = n - nLinks; mischSort(a,nLinks); mischSort(a+nLinks,nRechts); T* z = new T[n]; 143 Algorithmen und Datenstrukturen mische(a,nLinks,a + nLinks,nRechts,z); for (int i = 0; i < n; i++) a[i] = z[i]; delete [] z; } 5. Natürliches 2-Wege-Mischen Das Verschmelzen von nur aus einem Element bestehenden Teilfolgen kann häufig durch längere, bereits sortiert vorliegende Teilfolgen verbessert werden. Man versucht, eine natürliche, in der gegebenen Folge bereits enthaltene Vorsortierung auszunutzen. So zeigt bspw. das folgende Feld 27 18 37 55 68 12 16 8 87 95 63 sechs bereits sortiert vorliegende Teilfolgen: 27 18 37 12 16 8 87 55 68 95 63 Abb.: Die Teilfolgen können ermittelt und anschließend zusammengemischt werden: 18 27 37 55 68 8 12 16 87 95 63 95 63 Der Vorgang kann wiederholt werden. Das führt zur Folge 8 12 16 18 27 37 55 68 87 , die schließlich zu einer vollständig sortierten Folge umgestellt werden kann: 8 12 16 18 27 37 55 144 63 68 87 95 Algorithmen und Datenstrukturen 3.1.1.2 Externe Sortierverfahren Generell ist hier die zu sortierende Datenmenge so groß, daß sie nicht mehr vollständig im Arbeitsspeicher Platz findet. Die Daten sind in einem peripheren und sequentiellen Speichermedium (Band, Platte) enthalten. Die Daten sind grundsätzlich sequentielle Dateien (Files) mit der Eigenschaft, daß zu jeder Zeit genau eine Komponente zugreifbar ist. Diese Einschränkung verlangt die Verwendung anderer Techniken zum Sortieren. Am bedeutendsten ist hier: Sortieren durch Mischen 97. 3.1.1.2.1 Direktes Mischsortieren 2-Wege-Mischsortierverfahren Grundlagen. Das direkte Mischsortieren kann auf sequentielle „Files“ folgendermaßen angewandt werden: 1. Zerlegung einer gegebenen Sequenz (z.B. A) in 2 Hälften (z.B. B und C). 2. Mischen von B und C durch Kombination einzelner Elemente zu geordneten Paaren 3. Die gemischte Sequenz ist A. Wiederholung der Schritte 1 und 2, wobei die geordneten Paare nun zu Quadrupeln zusammenzufassen sind. 4. Wiederholung der vorhandenen Schritte, in der jedes Mal die Länge der gemischten Sequenzen verdoppelt werden, bis die ganze Sequenz geordnet ist. Bsp.: Gegeben ist die Sequenz A: 44 1. Schritt B: C: 44 94 55 18 12 06 42 67 A: 44 94 18 55 55 12 06 12 42 94 18 06 67 2. Schritt 42 67 3. Schritt B: C: 44 06 94 12 18 42 55 67 A: 06 12 44 94 4. Schritt 18 42 55 67 5. Schritt B: C: 06 18 12 42 44 55 94 67 A: 06 12 18 42 6. Schritt 44 55 67 94 Begriffe: - Phase: Jede Operation, die die ganze Menge der Daten einmal behandelt. - Durchlauf, Arbeitsgang: Der kleinste Teilprozess, dessen Wiederholung den Sortierprozess ergibt. Im Bsp. umfaßt das Sortieren 3 Durchläufe. Jeder Durchlauf besteht aus einer Zerlegungs- und Mischphase. Zum Sortieren werden 3 Bänder (sequentielle Files) benötigt, der Prozeß heißt 3-Band-Mischen. Das direkte Mischsortierverfahren verwendet Teillisten fester Länge. Das Verfahren besteht aus einer Reihe von (Durch-) Läufen, die mit nur ein Datenelement 97 vgl. 3.1.1.1, Sortieren durch Mischen 145 Algorithmen und Datenstrukturen umfassenden Teillisten beginnen. Jeder Lauf verdoppelt die Größe der Teillisten. Sortiert ist dann, wenn nur eine Teilliste mit allen Datenelementen in sortierter Folge vorliegt. Verfahrensaufwand. Sortiert ist dann, wenn nur eine Teilliste mit allen Datenelementen in sortierter Folge vorliegt. Erforderlich sind bei N Datenelementen ldN verschiedene Läufe, wobei alle N Datenelemente auf temporären Dateien und anschließend wieder zurück auf das Original kopiert werden. Das führt zu 2 ⋅ N ⋅ ldN Zugriffe. Algorithmus. Umfaßt das sequentielle „File“ N zu sortierende Datensätze, dann teilt man diese Datensätze in N/I Teilfolgen. Die Teilfolgen enthalten demnach höchstens I Datensätze. I ist die Anzahl der Datensätze, die (höchstens) in den Hauptspeicher passen. Man liest eine derartige Teilfolge (ein Intervall mit I Datensätzen) in den Internspeicher ein, sortiert sie mit einem der bekannten Arbeitsspeicher-Sortierverfahren und schreibt die sortierte Teilfolge zurück auf den Externspeicher, d.h. auf diverse sequentielle „Files“. Zu Beginn muß man diverse Datensätze auf dem „Eingabe-File“ auf mehrere „Files“ aufteilen (z.B. 2), dann verschmilzt man die inzwischen sortierten Teilfolgen. Die so entstandene Folge muß wieder aufgeteilt werden, bis man schließlich eine vollständig sortierte Folge erzeugt hat. Der Wechsel für Verteilungs- und Mischphase ist charakteristisch. Ausgeglichenes direktes Mischsortieren 98. Der bisher beschriebene und implementierte Verfahrensablauf wurde mit Hilfe von drei sequentiellen „Files“ realisiert. Nimmt man noch ein viertes File hinzu, dann kann die Verteilungs- und Mischphase zusammengefaßt werden (ausgeglichenes direktes Mischsortieren). Verfahrensbeschreibung: 4 Dateien d1, d2, d3, d4 sind gegeben. Eingabedatei ist d1. Es werden wiederholt eine bestimmte Anzahl (A) Datensätze eingelesen, intern sortiert und abwechselnd solange auf d3 und d4 geschrieben bis d1 erschöpft ist. Sortierte Teilfolgen (sog. Läufe, Runs) der Länge I stehen dann auf d3 und d4. Diese Läufe werden anschließend verschmolzen. Dabei entstehen Läufe mit 2*I langen Teilfolgen, die abwechselnd auf d1 und d2 verteilt werden. Nach jeder Aufteilungsund Verschmelzungsphase hat sich die Run-Länge verdoppelt und die Anzahl der Läufe etwa halbiert. Das Verfahren besteht also aus - dem Verschmelzen der Läufe von zwei Dateien und abwechselndem Verteilen aus den beiden anderen Dateien - dem (logischen) Vertauschen der Dateien bis schließlich nur ein Lauf auf einer der Dateien übrig bleibt. Bsp.: Der Hauptspeicher des Rechner faßt 3 Datensätze (I = 3). Die Dateien enthalten folgende Schlüssel: d1: 12, 2, 5, 15, 13, 6, 14, 1, 4, 9, 10, 3, 11, 7, 8 d2: A Datensätze werden jeweils von d1 gelesen, intern sortiert und auf d3 und d4 aufgeteilt: d3: 2, 5, 12, 1, 4, 14, 7, 8, 11 d4: 6, 13, 15, 3, 9, 10 d3 und d4 werden gelesen, d1 und d2 beschrieben: 98 vgl. PR33116.CPP 146 Algorithmen und Datenstrukturen d1: 2, 5, 6, 12, 13, 15, 7, 8, 11 d2: 1, 3, 4, 9, 10, 14 Es folgt: d3: 1, 2, 3, 4, 5, 6, 9, 10, 12, 13, 14, 15 d4: 7, 8, 11 und schließlich d1: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 d1 enthält zufälligerweise die sortierte Folge. Generell kann sie auf d1 oder d3 entstehen, wenn von den beiden Dateien d1 und d2 (bzw. d3 und d4) entstehende Läufe zuerst auf d1 und danach auf d2 (bzw. zuerst auf d3 und danach auf d4) geschrieben werden 99. Verfahrensaufwand: Nach jeder Verschmelzungs- und Verteilungsphase hat sich die Anzahl der Läufe etwa halbiert. Zu Beginn wurde aus N Datensätzen über ein internes Arbeitsspeichersortierverfahren N/I Läufe hergestellt. Damit ergibt sich nach log(N/I) Durchgängen ein einziger sortierter Lauf. Mehrwege-Mischsortierverfahren Verfahrensbeschreibung: Ausgangspunkt sind 2k sequentielle Files (Bänder): d1, d2,...,d2k. Es werden wiederholt I Datensätze von d1 gelesen und abwechselnd aud dk+1,dk+2,...,d2k geschrieben bis d1 erschöpft ist. Dann stehen N/(k-I) Läufe der Länge I auf di (k + 1 <= i <= 2k) Die k Files (Bänder) dk+1,...,d2k sind jetzt Eingabebänder für ein k-Wege-Mischen, die k Files d1,...,dk sind die Ausgabebänder. Die ersten Läufe der Eingabebänder werden zu einem Lauf der Länge k - l verschmolzen und auf das Ausgabeband d1 geschrieben. Danach werden die nächsten k Läufe der Eingabebänder verschmolzen und nach d2 geschrieben. So werden der Reihe nach Läufe der Länge k – l auf die Ausgabedateien geschrieben, bis die Eingabedateien erschöpft sind. Nach dieser Verschmelzungs- und Aufteilungsphase tauschen die Eingabe- und Ausgabedateien ihre Rollen. Das k-Wege-Verschmelzen und k-WegeVerteilen wird solange fortgesetzt, bis die gesamte Folge der Datensätze als ein Lauf auf einer der Dateien steht. Verfahrensaufwand 100: Zu Beginn werden mindestens ein Lauf, höchstens (N/I) Läufe und im Mittel (N/(2*I)) Läufe hergestellt. Nach jeder Verschmelzungs- und Verteilungsphase hat sich die Anzahl der Läufe um das 1/k-Fache vermindert. Implementierung 101in C++: Mehrphasen-Mischsortieren Beim ausgeglichenen Mehrwege-Mischsortieren werden alle Eingabedateien benutzt, aber nur auf eine der Ausgabedateien geschrieben. Die anderen Ausgabedateien sind temporär nutzlos. Da normalerweise die Zahl der Dateien viel kleiner ist als die Anzahl der Elemente (I) in einem Lauf der Anfangsverteilung wäre es wünschenswert, diese Dateien zu Eingabedateidateien heranzuziehen. Man will aber nicht alle Läufe auf ein einzige Ausgabedatei speichern, weil man sonst vor der 99 vgl. Ottman, T. / Wittmayer, P.: Algorithmen und Datenstrukturen, Mannheim ... 1990, S. 142 vgl. Ottman, T. / Wittmayer, P.: Algorithmen und Datenstrukturen, Mannheim ... 1990, S. 147 101 vgl. PR33118.CPP 100 147 Algorithmen und Datenstrukturen nachfolgenden Verschmelzungsphase noch eine zusätzliche Verteilungsphase einschieben müßte. Beim Mehrphasen-Mischsortieren 102 (polyphase mergesort) 103 arbeitet man mit (k+1) Dateien, von denen zu jedem Zeitpunkt k Eingabedateien sind und eine Ausgabedatei ist. Man schreibt solange alle entstehenden Läufe auf die Ausgabedatei bis eine der Dateien erschöpft ist 104. Dann wird die leere Eingabedatei zur Ausgabedatei, die bisher vorliegende Ausgabedatei dient als Eingabedatei. Damit besitzt man wieder k Eingabedateien und eine (andere) Ausgabedatei. Der Sortiervorgang ist beendet, falls die Eingabedateien erschöpft sind. Das Verfahren funktioniert nur dann, wenn zu jedem Zeitpunkt (außer am Schluß) nur ein Eingabeband leer wird. Bsp.: In einer Anfangsverteilung sind 13 Läufe l1 l2 l3 l4 l5 l6 l7 l8 l9 l10 l11 l12 l13 auf die Beiden dateien d1 und d2 folgendermaßen verteilt (d3 ist leer): d1 l1 l2 l3 l4 l5 l6 l7 l8 d2 l9 l10 l11 l12 l13 d3 leer Danach werden jeweils die nächsten Läufe von d1 und d2 verschmolzen und auf das Ausgabeband d3 geschrieben, bis d2 erschöpft ist. d1 l6 l7 l8 d2 leer d3 l1,9 l2,10 l3,11 l4,12 l5,13 Die erste Phase ist damit abgeschlossen. Die jeweils nächsten Läufe von d1 und d3 werden verschmolzen, bis d1 leer ist d1 d2 l6,1,9 l7,2,10 l8,3,11 d3 l4,12 l5,13 In den folgenden Phasen resultieren folgende Verteilungen: d1 l6,1,9,4,12 l7,2,10,5,13 l7,2,10,5,13 leer d2 l8,3,11 leer l7,2,10,5,13,6,1,9,4,12,8,3,11 d3 leer l6,1,9,4,12,8,3,11 leer Am Ende muß genau ein Lauf auf einer Datei stehen, der aus 2 Läufen resultiert, die jeweils auf zwei Dateien stehen. 102 vgl. Ottman, T. / Wittmayer, P.: Algorithmen und Datenstrukturen, Mannheim ... 1990, S. 148 vgl. Wirth, N.: Algorithmen und Datenstrukturen, Stuttgart 1979, S. 153 104 Das ist eine Phase. 103 148 Algorithmen und Datenstrukturen 3.1.1.2.2 Natürliches Mischen Zwei-Wege Mischsortieren Einführung. Beim direkten Mischen wird aus einer anfangs vorhandenen, teilweisen Ordnung kein Nutzen gezogen. Tatsächlich können 2 geordnete Teilsequenzen mit den Längen M und N direkt in eine Sequenz mit M + N Elementen eingemischt werden. Ein Mischsortieren, das immer die längsten möglichen Teilfolgen mischt, ist das natürliche Mischen. X[J] heißt (maximaler) Lauf, wenn Vereinbarung: Eine Teilsequenz X[I] .. folgende Bedingungen erfüllt sind: 1. X[K] <= X[K + 1] 2. X[I - 1] > X[I] 3. X[J] > X[J + 1] (für K = I .. J - 1) Die natürliche Mischsortierung mischt (maximale) Läufe statt fester Sequenzen mit vorbestimmter Länge. Jede Folge von natürlichen Zahlen zerfällt in eine solche Folge, so z.B.: 5 3 2 7 10 4 1 7 3 6 8 2 geordnete Sequenzen sind dann jeweils zu einer einzigen, geordneten Sequenz zu vereinigen. Verfahrensaufwand. Er wird danach gemessen, wie oft Läufe in die Betrachtung eingehen. Läufe haben die Eigenschaft, daß beim Mischen von 2 Sequenzen mit L Läufen eine einzige Sequenz mit genau L Läufen entsteht. So ergibt sich für die folgenden beiden Sequenzen 8 7 6 5 4 3 2 1 mit jeweils 4 Läufen die Sequenz 7 8 5 6 3 4 1 2 , die genau 4 Läufe besitzt. Die Zahl der Läufe wird in jedem Durchlauf halbiert. Im schlimmsten Fall ergibt sich dann die Anzahl der Bewegungen zu: L ld(L). Der Algorithmus. Ablauf: Die zu sortierenden Daten liegen im File F vor und sollen am Schluß in sortierter Form unter demselben Namen zurückgegeben werden. Die beiden Hilfsfiles sind G1 und G2. Jeder Durchlauf umfaßt eine Verteilungsphase (distribution), die Läufe gleichmäßig von F auf G1 und G2 verteilt, und eine Mischphase, die Läufe von G1 und G2 auf F mischt. 149 Algorithmen und Datenstrukturen G1 F G1 G1 F F F F ....... G2 G2 G2 Mischphase Verteilungsphase Abb.: Das Sortieren ist beendet sobald F nur noch ein Lauf ist. Für die Definition des momentanen Zustands eines Files stellt man sich am besten einen Positionszeiger vor. Er wird beim Schreiben um je eine Einheit vorwärts geschoben. Beschreibung: Sie erfolgt nach der Methode „stepwise refinement“. Grobstruktur des Prozesses: Wiederhole Setze die Zeiger aller 3 Files auf den Anfang; Verteile; Setze die Zeiger aller 3 Files auf den Anfang; Mische; bis L = 1; (* L ist die Anzahl der Läufe auf dem File F *) Verfeinerungsschritt: Verteile Wiederhole Kopiere ein Lauf F auf G1 Falls noch nicht eof(F), kopiere einen Lauf von F auf G2; bis Ende von F erreicht; Mische 150 Algorithmen und Datenstrukturen Setze L = 0; Solange weder eof(G1) noch eof(G2) fuehre aus: Mische je einen Lauf von G1 und G2 auf F; Erhoehe L um 1; Solange eof(G1) noch nicht erreicht, fuehre aus: Kopiere einen Lauf von G1 auf F; Erhöhe L um 1; Solange eof(G2) noch nicht erreicht, fuehre aus: Kopiere einen Lauf von G2 auf F; Erhöhe L um 1; 151 Algorithmen und Datenstrukturen 3.1.2 Suche in Texten 3.1.2.1 String Pattern-Matching 3.1.2.1.1 Ein einfacher Algorithmus zum Suchen in Zeichenfolgen 1. Problem Finden eines Teilstrings (Muster / Pattern) in einem anderen String. Suche erstes Vorkommen der Muster-Zeichenfolge pattern[0..m-1] im TextZeichenfolgen text[0...n-1] 2. Straightforward Lösung - Algorithmische Idee Starte beim ersten Zeichen im Text 105 und prüfe, ob die Zeichenfolge des Patterns mit der anfänglichen Zeichenfolge im Text übereinstimmt. Falls ja: Erfolg anderenfalls: Starte neu beim zweiten Zeichen im Text etc. Nicht gerade effizient: Anzahl von Zeichen-Vergleichen ist O(n*m) (m: Länge des Pattern, n: Länge des Texts) - Struktogramm Ansatz: Ab jeder Position i prüfen, ob der Test text[i..i + (m – 1)] mit dem Muster pattern übereinstimmt. letztes-bearbeitungswürdiges-Zeichen = textLaenge - musterLaenge Schleife über alle bearbeitungswürdigen Zeichenpositionen i im Text String substr = Substring im Text von Postion i bis i + Musterlänge substr stimmt mit Muster überein return: i return: -1 Implementierung mit charAt() bzw. substr() public static int search(String text, String pattern) { final int last = text.length() - pattern.length(); for (int i = 0; i <= last; i++) 105 Texte sind nicht weiter strukturierte Folgen beliebiger Zeichenketten aus einem Alphabet 152 Algorithmen und Datenstrukturen { int j; for (j = 0; j < pattern.length(); j++) { if (pattern.charAt(j) != text.charAt(i++)) break; } if (j == pattern.length()) return i; } return -1; } public static int search(String text, String pattern) { final int last = text.length() - pattern.length(); for (int i = 0; i <= last; i++) { String substr = text.substring(i,i+pattern.length()); if (substr.equals(pattern)) return i; } return -1; } 3. String-Matching mit endlichen Automaten Idee: Repräsentation eines Pattern als endlicher Automat. (Text als Input in den Automaten, Terminierung in Endzustand, wenn Pattern entdeckt.) Leider ist das Erstellen eines endlichen Automaten (die entsprechende Übergangstabelle) sehr aufwendig. Der Knuth-Morris-Pratt-Algorithmus arbeitet mit einer einfacheren Variante zum endlichen Automaten- einer sog. Verschiebetabelle, die in linearer Zeit in der Pattern-Länge konstruiert werden kann. 3.1.2.1.2 Der Algorithmus von Knuth-Morris-Pratt Idee: Bisherige Teilsuchergebnisse nutzen zur Verschiebung der Muster um mehr als eine Stelle. Tritt ein Missmatch an Position i des Patterns auf, so kann man a) das Pattern u.U. um mehr als eine Position weiterschieben b) braucht man die Position vor dem Missmatch nicht nochmals zu vergleichen. text b a c d b a b b a a a a b f a a a a pattern b a b b a f e a b a b b a f e a Definitionen: - pattern[0..k] (k <= m-1) heißt Präfix vom pattern[0..m-1] - pattern[l...m-1] (l >= 0) heißt Suffix von pattern [0...m-1] - Man spricht von echtem Praefix / Suffix, wenn k < m-1 bzw. l > 0 - Eigentlicher Rand von pattern ist der längste Teilstring von pattern, der sowohl echtes Präfix als auch echtes Suffix von pattern ist. 153 Algorithmen und Datenstrukturen Bsp.: UNGLEICHUNG hat eigentlichen Rand UNG Ränder können sich überlappen. Bsp.: Der eigentliche Rand von aabaabaa ist aabaa. aa ist ein Rand aber nicht der eigentliche Rand. Vorarbeit zur KMP-Suche: Zunächst für alle Teilmuster pattern[0..j-1]: Länge des eigentlichen Rands in der Shift-Tabelle next[j] speichern. Bsp.: text ...UNGLEICHUNGSTEIL... i-j pattern i UNGLEICHUNGEN next[j] j UNGLEICHUNGEN next[j] - 1. Mismatch (von links) bei text[i] und pattern[j] => text[i-j...i-1] == pattern[0...j-1] und text[i] != pattern[j} - Zurücksetzen von j auf j' = next[j] - Trick: Vergleichen beginnt zwischen text[i] und pattern[j] Definition der Shift-Tabelle j=0 ⎧− 1 next[ j ] = ⎨ ⎩∂ ( s 0 ...s j −1 ) j ≥ 1 ∂ ( s ) bezeichnet den eigentlichen Rand vom pattern. Das Teilwort s stimmt ab der Position i mit dem zugehörigen Teilwort von text[i] bzw. s0 mit text[i+j-1] bzw. s j −1 überein, d.h. text[i+j] <> s j . Der zum Teilwort s 0 ...s j −1 gehörende eigentliche Rand hat laut Definition die Länge next[j]. Verschiebt man s um j – next[j] nach rechts, so kommt der rechte Rand des Teilworts s 0 ...s j −1 von s auf dem linken Rand zu liegen, d.h. man schiebt Gleiches auf Gleiches. Da es keinen längeren Rand von s 0 ...s j −1 als diesen gibt, der ungleich s 0 ...s j −1 ist dieser Shift sicher. 154 Algorithmen und Datenstrukturen text [0] [i] pattern [i+j] [0] [j] a b a a b a a b a a b a j-next[j] next[j] Eigentlicher Rand von s 0 ...s j −1 a b a Abb.: Shift um j-next[j] Implementierung der Shift-Tabelle In der Tabelle next[] wird für jedes Präfix s 0 ...s j −1 die Länge 0...m des Suchstrings pattern der Länge m gespeichert, wie groß dessen eigentlicher Rand ist. Initialisierung: next[0] = -1, next[1] = 0 Annahme: next[0]...next[j-1] seien bereits berechnet. Ziel: Berechnung von next[j]=Länge des eigentlichen Rands eines Suffixes der Länge j Ist s next[ j −1] = s j −1 , dann ist next[j]=next[j-1]+1. Anderenfalls müsste man ein kürzeres Präfix von s 0 ...s j − 2 finden, das auch ein Suffix von s 0 ...s j − 2 ist. Der nächsthöhere Rand ist iffensichtlich der eigentliche Rand des zuletzt betrachteten Rands des Worts: Nach der Konstruktion der Tabelle next ist das nächstkürzere Präfix mit dieser Eigenschaft das der Länge next[next[j-1]]. Es folgt der Test, ob sich dieser Rand von s 0 ...s j − 2 zu einem eigentlichen Rand von s 0 ...s j −1 erweitern lässt. Das wird solange wiederholt, bis ein Rand gefunden ist, der sich zu einem Rand von s 0 ...s j −1 erweitern lässt. Falls sich kein Rand von s 0 ...s j − 2 zu einem Rand von s 0 ...s j −1 erweitern lässt, dann ist der eigentliche Rand von s 0 ...s j −1 das leere Wort und man setzt next[j] = 0. Der Inhalt der Tabelle next[] kann durch Vergleichen der Teilmuster aus pattern mit sich selbst, um 1 verschoben, ermittelt werden. public static int[] initNext(String pattern) { final int m = pattern.length(); int next[] = new int[m]; int i = 0; int j = -1; next[0] = -1; while (i < (m - 1)) { while(j >= 0 && (pattern.charAt(i) != pattern.charAt(j))) j = next[j]; ++i; ++j; next[i] = j; } return next; } 155 Algorithmen und Datenstrukturen Bsp. und Test: next[j] j=1 A B C A A B 2 A B A C B A C A A B A A B C A A B A C B A A B C A A A B B C A A B A A A B A B C B A C A A B A 3 A 4 A 5 B A B C = 0 0 0 1 B 1 Abb.: Die Tabelle next[] für das Pattern ABCAAB Implementierung KMP-Suche Mit der aus dem letzten Beispiel bestimmten Shift-Tabelle j next[j] 0 -1 1 0 2 0 3 0 4 1 5 1 ergeben sich für den folgenden Text folgende Vergleiche: text [0] A Vergleichsrichtung B C A B A pattern [0] [1] B [2] [3] [4] [5] A B C A A B 1 2 3 4 5 j = 4, next[4] = 1 A B 6 C A B A A B B C A B A A A B B 7 j = 2, next[j] = 0 A B C 8 9 10 j = 2, next[j] = 0 A A B C A 11 j = 0, next[j] = -1 => i++, j = 0 A B C A A B 12 13 14 15 16 17 Das führt zu folgenden Quellcodeanweisungen: // Knuth-Morris-Pratt-Methode 156 B Algorithmen und Datenstrukturen public static int search(String text, String pattern) { int next[] = initNext(pattern); final int n = text.length(); final int m = pattern.length(); int j = 0; // Position in pattern int i = 0; // Position in text while (i < n) { while (j >= 0 && (pattern.charAt(j) !=text.charAt(i))) { j = next[j]; } ++i; // im Text eine Position weitergehen ++j; if (j == m) { return (i - m); // Muster ganz gefunden } } return -1; } Komplexität von KMP-Textsuche - Such-Phase: In jedem Schritt entweder im Text um ein Zeichen weitergehen (++i) oder Muster um mindestens 1 Zeichen weiter rechts anlegen j = next[j] Æ Aufwand O(n). - Initialisieren der next-Tabelle (läuft genau wie Suche ab): Aufwand O(m) - KMP-Algorithmen insgesamt: O(m+n) - Zusätzlicher Platzbedarf O(m) 3.1.2.1.3 Boyer / Moore - Suche Neuer Ansatzpunkt zum Suchen in Texten: Zu suchendes Wort in einem Textstück nicht mehr von links nach rechts sondern von rechts nach links vergleichen. Ein Vorteil dieser Vorgehensweise ist, dass man in Alphabeten mit vielen unterschiedlichen Symbolen bei einem Mismatch an der Position i + j im Textstück , i auf i + j + 1 setzen kann, falls das im Textstück gesuchte Zeichen an der Position i + j nicht im gesuchten Wort vorkommt. 1. Simple BM 106 Grundüberlegung: Muster an Position i am text "anlegen" und von rechts nach links mit Text vergleichen. Falls: - 1.Mismatch zwischen pattern[j] und text[i+j] (tij) - und tij kommt irgendwo im Muster vor Muster um j+i Zeichen verschieben => im günstigsten Fall (Alphabet groß genug, nur wenig verschiedene Zeichen im Muster) kann oft um gesamte Musterlänge verschoben werden - bad-character Heuristik 106 In der Literatur gibt es verschiedene Varianten unter dem Namen "Boyer/Moore"-Algorithmus. Die hier beschriebene Variante entspricht dem sog. "bad character"-Teil des Algorithmus. 157 Algorithmen und Datenstrukturen Fall a): Zeichen im text, an dem ein Mismatch auftritt, kommt im Muster nicht vor => Muster so weit verschieben, dass es hinter Mismatch-Position anfängt. A C B B D A A B C A B A A A B C A B B C A B A A .. Vergleichsrichtung Fall b.1) Zeichen im text, an dem Mismatch auftritt, kommt im Muster vor, und zwar nur vor aktueller Stelle im Muster => Muster so weit verschieben, dass diese Musterposition an der Mismatch-Position im text anliegt. A C B B D A A B D A B A A B D A A B B A C A B A .. Vergleichsrichtung Fall b.2) Zeichen im text, an dem Mismatch auftritt, kommt im Muster vor, und zwar hinter der aktuellen Stelle im Muster => Muster um eine Position weiterschieben A C B C B A B A D C B A B A D C B A B C A B A .. A Vergleichsrichtung Bsp.: A A A B B C B A A C B A C A B A B A C C B A C C B C B B B A B C A A C D A C A B A B C B A A B A B C B A C B A B C B A "last"-Tabelle enthält zu jedem Zeichen des Zeichensatzes die Position des letzten Vorkommen im Muster (oder "-1", falls es nicht vorkommt). Implementierung z.B. als Array indiziert mit (Unicode)-Zeichensatz: 'A' auf Index 65, 'B' auf 66 usw., 'a' auf 97, 'b' auf 98 usw. 158 Algorithmen und Datenstrukturen Bsp.: "last"-Tabelle des Muster "bananas" pattern Index im Muster Unicode-Index b 0 98 a 1 97 n 2 110 a 3 97 "last"-Wert 0 5 4 5 ... 0-96 -1 a 97 5 b 98 0 ... 99-109 -1 n 4 11 0 4 n 110 4 a s 5 6 97 115 5 6 ... 111-114 -1 s 115 6 … 116-127 -1 Implementierung "last"-Tabelle private static int[] initLast(String pattern) { // Platz fuer ASCII-Zeichen (Unicode 0 - 255) int [] last = new int[256]; int i; for (i = 0; i < 255; i++) last[i] = -1; // nach vorbelegen mit -1 fuellen for (i = 0; i < pattern.length(); i++) last[pattern.charAt(i)] = i; return last; } Implementierung Simple BM Die Anwendung der vorliegenden "last"-Tabelle auf folgenden text o r a n g e s b a n a n a s b , a a n n a n a s b a n a n b a a n n a a s a n a n d b a n a n a s s a s b a n a n a s b a n a n a s b a n a n Verschiebedistanz = max(1,,j – last[text[i+j]]) Vergleichsrichtung führen zu dem Simple-BM-Algorithmus public static int search(String text, String pattern) { int last[] = initLast(pattern); final int lastidx = text.length() - pattern.length(); int i = 0; while (i <= lastidx) { // pattern vergleich ab [i] // suche nach mismatch von rechts nach links int j = pattern.length() - 1; while (j >= 0 && pattern.charAt(j) == text.charAt(i+j)) --j; // match, dann naechstes Zeichen 159 a s Algorithmen und Datenstrukturen if (j < 0) // Muster ganz gefunden return i; else // sonst: pattern verschieben i += Math.max(1,j - last[text.charAt(i+j)]); } return -1; // Muster nicht gefunden } Laufzeitverhalten (unter Annnahme n>>m). - - O(n*m) im schlimmsten Fall. Zutreffend für ungünstige Text/Pattern Kombination, z.B. Text: "a*", Muster: "baaaaaa" Im Normalfall (Text und Muster sind sich sehr unähnlich) geht es aber viel schneller. Wenn Alphabet des Textes groß im Vergleich zu m: nur etwa (O(n/m) Vergleiche. Nur sinnvoll, wenn das Alphabet groß ist (z.B. ASCII/Unicode). Für Bitstrings ist dieses Verfahren weniger gut geeignet. 2. BM Der von R.S. Boyer und J.S. Moore vorgeschlagene Algorithmus unterscheidet sich von den vorstehenden naiven Ansätzen in der Ausführung größerer Shifts, die in einer Shift-Tabelle gespeichert sind. Bestimmen der shift-Tabelle. Zu Beginn wird die Shift-Tabelle an allen Stellen mit der Länge des Suchstrings initialisiert. Im wesentlichen entsprechen mögliche Shifts der Bestimmung von Rändern von Teilwörtern des gesuchten Worts. Im Unterschied zum KMPAlgorithmus wird zusätzlich zu den Rändern von Präfixen des Suchworts auch nach Rändern von Suffixen des Suchworts gesucht. Mögliche Shifts beim Boyer-Moore-Algorithmus. text i i+j [0] j n-1 m-1 pattern σ j- σ j m-1 σ m- σ σ m- σ Abb.: Zulässige Shifts bei Boyer-Moore Prinzipiell gibt es 2 mögliche Arten eines "vernünftigen" Shifts. Im oberen Teil ist ein "kurzer" Shift angegeben, bei dem im grünen Bereich die Zeichen nach dem Shift weiter übereinstimmen. Das rote Zeichen im text, das den Mismatch ausgelöst hat, wird nach dem Shift auf ein anderes Zeichen im pattern treffen, damit überhaupt 160 Algorithmen und Datenstrukturen die Chance auf Übereinstimmung besteht. Im unteren Teil ist ein "langer" Shift angegeben, bei dem die Zeichenreihe von pattern so weit verschoben wird, so dass an der Position des Mismatch im text gar kein Vergleich mehr entsteht. Allerdings soll auch hier im schraffierten Bereich wieder Übereinstimmung mit den bereits verglichenen Zeichen im text herrschen. Die Kombination der beiden Regeln nennt man die Good-Suffix-Rule, da man darauf achtet, die Zeichenreihe so zu verschieben, dass im letzten übereinstimmenden Bereich wieder Übereinstimmung herrscht. Ermitteln der in der Shift-Tabelle zu speichernden Werte: Der erste Mismatch soll im zu durchsuchenden Text an der Stelle i+j auftreten. Da der Boyer-MooreAlgorithmus das Suchwort von hinten nach vorn vergleicht, ergibt sich folgende Voraussetzung: s j +1 ...s m −1 = t i + j +1 ...t i + m −1 ∧ s j ≠ ti+ j Um einen nicht nutzlosen Shift um σ Positionen zu erhalten, muß gelten: s j +1−σ ...s m −1−σ = t i + j +1 ...t i + m −1 = s j +1 ...s m −1 ∧ s j ≠ s j −σ Diese Bedingung ist nur für "kleine" Shift mit σ ≤ j sinnvoll 107. Für größere Shift σ > j muß gelten, dass das Suffix des übereinstimmenden Bereichs mit dem Präfix des Suchworts übereinstimmt, d.h. s 0 ...s m −1−σ ...s m −1−σ = t i +σ ...t i + m −1 = s j +1 ...s m −1 Bsp.: Shift-Tabelle für den Suchstring "ababbababa" Teil 1: σ ≤ j [0] [1] a b [2] a [3] [4] [5] [6] [7] [8] [9] b b a b a b a b a ≠ a b shift[9] = 1 a = b a b a a b a a b a = a b = b a b = 107 Ein solcher Shift ist im obigen Bild als erster Shift zu finden. 161 Algorithmen und Datenstrukturen b b a b a b a a b a b a ≠ b b ≠ b b shift[5] = 2 a b a b a ≠ b b shift[7] = 4 a b a b a ≠ b a b shift[9] = 6 108 b a b a b a b b a b a b a b b a b a b a = a b a = a b a Teil 2: σ > j a b a b b a b σ =7 bei Mismatch an Position a b j ∈ [0 : 6] shift[j] = 7 a b b a b a b a a b a b b a b a b a σ =9 bei Mismatch an Position a b a b a a b a b b a b a b a j ∈ [7 : 8] shift[j] = 9 a b b a b a b a a b a b b a b a b a σ = 10 bei Mismatch an Position j ∈ [9] shift[j] = 10 Zusammenfassung: shift [0] 7 [1] 7 [2] 7 [3] 7 [4] 7 [5] 2 Implementierung der Shift-Tabelle 109 private static int[] initShift(String pattern) { int m = pattern.length(); 108 109 Dieser Wert nicht gespeichert, da s[9] schon mit 1 belegt ist. pr31200 162 [6] 7 [7] 4 [8] 9 [9] 1 Algorithmen und Datenstrukturen int[] shift = new int[m+1]; int[] suffix = new int[m+1]; int i, j, h = 0; suffix[m-1] = m; j = m-1; for(i = m-2; i >= 0; --i) { if (i > j && suffix[i+m-1-h] < i - j) suffix[i] = suffix[i+m-1-h]; else { if ( i < j ) j = i; h = i; while( j >= 0 && pattern.charAt(j) == pattern.charAt(j+m-1-h) ) --j; suffix[i] = h - j; } } for (i = 0;i < m; ++i) shift[i] = m; j=0; for(i = m-1; i >= -1; --i) if(i==-1 || suffix[i]==i+1) while( j < m-1-i) { if(shift[j] == m) shift[j] = m-1-i; ++j; } for(i = 0;i < m-1; ++i) shift[m-1-suffix[i]] = m-i-1; return shift; } // Ende initShift() Implementierung Boyer-Moore (Suchfunktion) public static int search(String text, String pattern) { int i = 0; int last[] = initLast(pattern); // last-Tabelle int shift[] = initShift(pattern); // shift-Tabelle while(i<=text.length()-pattern.length()) { // pattern-Vergleich ab [i] int j = pattern.length() - 1; // suche nach mismatch von rechts nach links while(j >= 0 && pattern.charAt(j) == text.charAt(i+j)) --j; if(j < 0) return i; else i += Math.max(shift[j], j-last[text.charAt(i+j)]); } return -1; } Komplexität: In der Vorbereitungsphase beträgt der Aufwand für die Erstellung der Shift-Tabelle O(m) , für die Erstellung der last-Tabelle O(m + Σ ) . Unter der Voraussetzung, dass das Muster nicht oder wenige Male im Text vorkommt, werden im schlechtesten Fall O(n) Vergleiche benötigt. Bei einem im Vergleich zur Länge des Musters großen Alphabet beträgt die Anzahl der Vergleiche sogar nur O(n / m) . In den eher seltenen Fällen, wo ein Suffix des Musters sehr häufig im Text vorkommt (z.B. beim Suchen des Musters AB m −1 im Text B n ist der Aufwand O(nm) . 163 Algorithmen und Datenstrukturen 3.1.2.2 Pattern-Matching mit regulären Ausdrücken Bisher wurde eine konkrete Zeichenfolge gesucht. Jetzt soll die Suche nach einem allgemeinen Muster erfolgen. Dazu wird benötigt: - Notation zur Beschreibung allgemeiner Ausdrücke => reguläre Ausdrücke Mechanismus zur Erkennung solcher Muster => endliche Automaten Mit Automaten definiert man die Worte einer Programmiersprache. Reguläre Ausdrücke können aus regulären Sprachen abgeleitet werden. Eine Sprache L wird über dem Alphabet Σ ( d.h. eine endlichen Menge von Zeichen) gebildet: L ⊆ Σ * . Σ * ist die Menge aller Wörter über Σ* = {ε , a, b, aa, ab, ba, aaa,...} - Ein Wort über dem Alphabet Σ ist eine endliche Menge von Zeichen aus Σ Spezialfall: leeres Wort ε - Σ . Falls bspw. Σ = {a, b} ist, dann ist Ein Sonderfall bilden reguläre Sprachen. Für sie gilt folgende rekursive Definition: {ε } ist eine reguläre Sprache über Σ 2. ∀σ ∈ Σ . Die Menge {σ } ist eine reguläre Sprache über Σ 1. Die Menge 3. Falls L, L1 , L2 ⊆ Σ * regulär sind, dann sind es auch folgende Sprachen Vereinigungsmenge L1 ∪ L2 = {w | w ∈ L1 ∨ w ∈ L2 } Konkatenation L1 o L2 = {w1 w2 | w1 ∈ L1 ∧ w2 ∈ L2 } Wiederholung L* = {ε } ∪ L ∪ L o L ∪ L ∪ L o L o L ∪ ... 3.1.2.2.1 Reguläre Ausdrücke Reguläre Ausdrücke können aus regulären Sprachen abgeleitet werden: 1. die leere Zeichenkette ε ist ein regulärer Ausdruck mit L(ε ) = {ε } 2. ∀σ ∈ Σ ist ein regulärer Ausdruck mit L(σ ) = {σ } 3. Reguläre Ausdrücke R, S mit L( R ) = LR , L ( S ) = LS können mit den folgenden Verknüpfungsoperationen komplexe Ausdrücke bilden: Klammerung T = ( R) mit L(T ) = LR L(T ) = LR o LS Oder T = R | S mit L(T ) = LR ∨ LS Hüllenbildung T = R * mit L (T ) = LR * Verkettung T = RS mit Für Pattern-Matching mit regulären Ausdrücken existieren Pattern-Matcher. Diese Matcher basieren typischerweise auf endlichen Automaten. Das grep-Kommando implementiert einen Matcher für reguläre Ausdrücke. Die Programmiersprache Perl ist im wesentlichen ein Matcher für reguläre Ausdrücke. Natürlich können Matcher für reguläre Ausdrücke auch String-Pattern-Matching, konstante Strings sind spezielle reguläre Ausdrücke. 164 Algorithmen und Datenstrukturen Neben den standardmäßig zur Beschreibung regulärer Ausdrücke verwendbaren Konstrukte werden einige Zusatzkonstrukte erlaubt, die es einfacher machen reguläre Ausdrücke aufzuschreiben. Die folgende Tabelle zeigt dafür einen Überblick: Zeichen x Zeichen x \\ Backslash \t Tab \n Newline \cx Control-Zeichen x ... Zeichenklassen [abc] einfache Klasse [ˆabc] Negation [a-zA-Z] inklusiver Bereich [a-z-[bc]] Subtraktion [a-z-[m-p]] Subtraktion mit inkl. Bereich [a-z-[ˆdef]] Vordefinierte Zeichenklassen Beliebiges Zeichen . eine Ziffer \d keine Ziffer \D Trenner (whitespace) \s kein Trenner \S Textzeichen \w kein Textzeichen \W Begrenzer Zeilenanfang ˆ Zeilenende $ Wortgrenze \b keine Wortgrenze \B ... Greedy Quantoren 0 bis n des vorangestellten Zeichens * Kleene-Stern 1 bis n des vorangestellten Zeichens + das vorangestellte Zeichen 0- oder ? 1-mal ... Weitere Quantoren ... Quotation markiert das folgende Zeichen als \ “wörtlich zu nehmen” Logische Operation XY Sequenz (X gefolgt von Y) X|Y Oder (a, b oder c) (ein beliebiges Zeichen ausser a, b, oder c) (alle Groß- und Kleinbuchstaben) (a bis Z ausser b und c) (a bis z ausser m bis p) (d, e, oder f) [0-9] [ˆ0-9] [ \t\n\x0B\f\r] [a-zA-Z_0-9] weitere Verwendung: Negation Abb.: Konstruktion regulärer Ausdrücke Bsp.: Der reguläre Ausdruck "[a-z]+" deckt eine Folge von einem oder mehreren Kleinbuchstaben ab. [a-z] bedeutet: irgendein Zeichen von a bis z, zusätzlich bedeutet + "ein" oder mehrere. Angenommen wird, dass dieses Muster auf den String "Now in the time" angewendet wird. Es gibt 3 Wege, wie dieses Muster angewendet werden kann: 165 Algorithmen und Datenstrukturen - auf den vollständigen String: Es führt zur Fehlanzeige, weil der String auch andere Buchstaben benutzt als Kleinbuchstaben. auf den Anfang der Zeichenkette: Es führt zur Fehlanzeige, weil der String nicht mit einem Kleinbuchstaben anfängt. auf Suche im String: Es ist erfolgreich und passt auf ow. Falls wiederholt angewendet, findet man is, the, time. Danach gibt es eine Fehlanzeige. Kann das in diesem Bsp. enthaltene Problem in Java gelöst werden? Vor Java 1.4 konnte Pattern-Matching nur umständlich mit Hilfe der StringTokenizer- und charAt()-Methoden realisiert werden. Mit Java 1.4 gibt es folgende Lösungsmöglichkeit: - Zuerst muß das pattern kompiliert werden import java.util.regex.*; Pattern p = Pattern.compile("[a-z]+"); - Dann muß ein Matcher für ein bestimmtes Stück Text erzeugt werden, in dem eine Nachricht an das Muster (pattern) gesendet wird: Matcher m = p.matcher("Now is the time"); Vollständiges Bsp. 110: import java.util.regex.*; public class RegexTest { public static void main(String args[]) { String pattern = "[a-z]+"; String text = "Now is the time"; Pattern p = Pattern.compile(pattern); Matcher m = p.matcher(text); while (m.find()) { System.out.print(text.substring(m.start(),m.end())+"*"); } } } // Ausgabe: ow*is*the*time* Allgemein können reguläre Ausdrücke durch Strings über Variablen ersetzt werden. Hierzu werden in regulären Ausdrücken Gruppen gebildet, z.B.: - ([a-zA-Z]*)([0-9]*) führt zur Übereinstimmung mit einer Anzahl Buchstaben, gefolgt von einer Anzahl Ziffern - \[([a-z])\.([A-Z])\] kann durch (\1,\2) ersetzt werden. Gruppen werden durch Klammern eingeschlossen. Capturing groups werden nummeriert durch Zählen der öffnenden Klammern von links nach rechts, z.B.: ((A)(B(C))) 12 3 4 \0=\1=((A)(B(C))), \2=(A), \3=(B(C)), \4=(C) 110 vgl. pr31250 166 Algorithmen und Datenstrukturen 3.1.2.2.2 Überprüfung regulärer Ausdrücke mit endlichen Automaten Definition eines nichtdeterministischen, endlichen Automaten (NEA) Ein nichtdeterministischer endlicher Automat (NEA) ist definiert durch ein Quintupel mit 1. einer endlichen Zustandsmenge S 2. einer Menge ∑ (oder auch Alphabet) von Eingabesymbolen 3. einem Zustand s0, der als Start- oder Endzustand bezeichnet wird 4. eine Menge F von Zuständen, die als akzeptierte oder Endzustände bezeichnet werden 5. einer Übergangsfunktion δ : S × (Σ ∪ {ε }) . Ein endlicher Automat lässt sich als markierter, endlicher Graph darstellen, wobei - Knoten die Zustände markierte Kanten die Übergangsfunktion repräsentieren. Ein endlicher Automat akzeptiert eine Zeichenfolge genau dann, wenn es einen Pfad vom Startzustand zu einem Endzustand gibt und die Markierungen der Kanten des Pfads genau diese Zeichenfolge bilden 111. Da die Übergangsfunktion eine Menge von Zuständen (Potenzmenge, Folgezustand nicht eindeutig) liefert, handelt es sich um einen nichtdeterministischen endlichen Automaten (NEA). Dies ist für die Erkennung regulärer Ausdrücke sinnvoll, weil durch die Oder- oder Hüllenoperationen mehrere (d.h. zwei) Übergänge aus einem Zustand möglich sind. Bsp.: A A 0 B 1 A 2 3 B Abb.: Beispiel für einen nichtdeterministischen endlichen Automaten für die Erkennung des Ausdrucks A(A+B)*BA, Zustandsmenge S={0,1,2,3}, Alphabet ∑ = {A,B} Satz von Kleene - Zu jedem regulären Ausdruck r gibt es einen NEA M, der die von r beschriebene Sprache L(r) akzeptiert - Zu jedem NEA M gibt es einen regulären Ausdruck, der die von M akzeptierte Sprache L(M) beschreibt In beiden Fällen ist L(r) = L(M). Es kann also folgendermaßen überprüft werden, ob eine Zeichenfolge w zu einem regulären Ausdruck passt: 1. Konstruktion eines NEA M zu r 111 Beim KMP-Algorithmus wird die Kodierung eines endlichen Automaten als "next"-Tabelle benutzt. 167 Algorithmen und Datenstrukturen 2. Prüfen, ob M die Zeichenfolge w akzeptiert, d.h. Simulation von M (Breitensuche im Zustandsdiagramm) Konstruktion eines NEA zu einem regulären Ausdruck - Eingabe des regulären Ausdrucks r über ∑ - Ausgabe: NEA M, der L(r) akzeptiert - Algorithmus: -- Zerlege r in Bestandteile -- Erzeuge für jeden Term in r einen regulären Ausdruck und konstruiere entsprechend der rekursiven Definition von regulären Ausdrücken aus diesen NEAs einen NEA, der L(r ) akzeptiert a) zu jedem atomaren Symbol aus Σ ∪ {ε } b) zu jeder Verkettung c) zu jeder Oder-Verknüpfung d) zu jeder Hüllenbildung für Klammerung (s) nehme Ms a) Zu jedem atomaren Symbol σ ∈ ∑ oder ε (dem leeren String) wird ein eigener Automat erstellt, der aus einem Startzustand, einen Endzustand sowie einer Kante besteht, die beide Zustände verbindet und mit dem jeweiligen Symbol markiert ist. σ ε Start Start Abb.: NEA zu jedem Buchstaben σ (der im regulären Ausdruck vorkommt) bzw. ε Die einzelnen Automaten werden anschließend entsprechend der definierten Operationen verknüpft: Ms Start Mt Abb.: NEA für Oder-Verknüpfung s + t bzw. s | t Start Ms Mt Abb.: NEA für Verketttung st 168 Algorithmen und Datenstrukturen ε ε ε Start Ms ε Abb.: NEA für Hüllenbildung s* ε ε Start 0 ε A 1 B 2 A 3 4 5 ε Abb.: Aus A*BA konstruierter NEA Die Repräsentation der Zustände und Übergänge erfolgt durch eine Tabellendarstellung, wobei für jeden Zustand (state) die mit einem gelesenen Symbol (symbol) durchzuführenden Übergänge (next) zu den Folgezuständen angegeben sind. Da es für die speziell nach den vorstehenden Regeln konstruierten Regeln bis zu 2 Folgezustände geben kann, werden für die Übergänge entsprechend 2 Folgezustände next1 und next2 benötigt. state symbol next1 next2 0 ε 1 3 1 A 2 2 2 3 B 4 4 ε 3 1 4 A 5 5 5 ε 0 0 Abb.: Repräsentation eines NEA, der aus A*BA konstruiert ist Simulation eines NEA Alle Zustände, die während des Verarbeitens eines bestimmten Symbols eingenommen werden können, sind zu sichern und später der Reihe nach abzuarbeiten. Die Implementierung nutzt die Datenstruktur Deque (Kombination von Warteschlange und Kellerspeicher). Die Warteschlange wird benötigt, weil erst alle Zustände des aktuellen Zeichen untersucht werden müssen, bevor mit dem nächsten Zeichen fortgefahren wird. Der neue Zustand wird am Ende der Warteschlange eingeordnet. Ein Kellerspeicher ist zur Verarbeitung von Nullzuständen mit ε Übergängen notwendig, da diese zur sofortigen Untersuchung als erste Elemente eingeordnet werden sollen. import java.util.LinkedList; public class NEA { public static final int SCAN = -1; // Klasse zur Repräsentation der Zustände static class State 169 Algorithmen und Datenstrukturen { public State(char s, int n1, int n2) { symbol = s; next1 = n1; next2 = n2; } char symbol; // zu akzeptierendes Symbol int next1, next2; // Nachfolgezustaende } // "Programm" des NEA State[] states = { new State(' ', 1, 3), new State('A', 2, 2), new State(' ', 3, 1), new State('B', 4, 4), new State('A', 5, 5), new State(' ', 0, 0) }; public NEA() {} public boolean match(String s) { /* Passt die uebergegebene Zeichenkette s zum Muster des Automaten */ LinkedList deque = new LinkedList(); // Initialisierung int j = 0, state = states[0].next1; deque.addLast(new Integer(SCAN)); // Ablauftabelle - Ueberschrift while (state != 0) { if (state == SCAN) { j++; deque.addLast(new Integer(SCAN)); } else if (states[state].symbol == ' ') { // "leeres" Zeichen -> Nullzustand int n1 = states[state].next1; int n2 = states[state].next2; deque.addFirst(new Integer(n1)); if (n1 != n2) deque.addFirst(new Integer(n2)); } else if (states[state].symbol == s.charAt(j)) // Zeichen akzeptiert deque.addLast(new Integer(states[state].next1)); if (deque.isEmpty() || j > s.length()) // kein Endzustand erreicht -> Fehler return false; // (!) neuen Zustand einnehmen state = ((Integer) deque.removeFirst()).intValue(); } // Endzustand: Eingabe akzeptieren System.out.println(); return true; } public static void main(String[] args) { NEA nea = new NEA(); System.out.println("accept = " + nea.match("AABA")); } } 170 Algorithmen und Datenstrukturen Abb.: Ablauf bei der Erkennung von AABA 3.1.2.2.3 Java 1.4 "regex" Pattern und Matcher sind im Paket java.util.regex. Weder Pattern noch Matcher besitzen Konstruktoren, Instanzen werden über Methoden der Klasse Pattern gebildet. Der Matcher umfasst Informationen, wie das pattern anzuwenden ist und den text, auf den es angewendet wird. Die Pattern-Klasse Die Pattern-Klasse repräsentiert einen regulären Ausdruck, der als String spezifiziert wurde. Mit der Klassenmethode Pattern.compile(string) wird das Pattern in eine effiziente interne Repräsentation umgewandelt. So erzeugt Pattern p = Pattern.compile("[,\\s]+"); ein Pattern für Trennung durch Komma oder Whitespace Weitere Methoden: - static Pattern compile(String regex, int flags): Übersetzt den regulären Ausdruck in ein Pattern Objekt mit Flags. Als Flags sind erlaubt: CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE und CANON_EQ. - int flags() liefert die Flags, nach denen geprüft wird. - String split(Charsequene input): Zerlegt die Zeichenfolge in Teilzeichenketten, wie es das aktuelle Pattern-Objekt befiehlt. - String split(Charsequene input, int limit): wie split(CharSequence), nur durch limit begrenzt viele Zeichenkettem. Mit split() aus Pattern (oder String) kann eine Trennfolge definiert werden, die eine Zeichenfolge in Teilzeichenketten zerlegt, ähnlich wie es der StringTokenizer macht. Der StringTokenizer ist jedoch beschränkt auf einzelne Zeichen als Trennsymbole, während die Methode split() einen regulären Ausdruck zur Beschreibung verwendet. - Matcher matcher(CharSequence input): erzeugt einen Matcher, der gegebenen Input gegen das Pattern vergleicht, z.B.: Matcher m = p.matcher("onetwothree four fivesix”); 171 Algorithmen und Datenstrukturen - static boolean matches(String regex, CharSequence input) liefert true, wenn der reguläre Ausdruck regex auf die Eingabe paßt. - String pattern() liefert den regulären Ausdruck, den das Pattern repräsentiert. Im Prinzip besteht das Erkennen eines Musters immer aus dem Aufbau eines Pattern-Objekts mit regulärem Ausdruck und Prüfung: Pattern p = Pattern.compile("a*b"); Matcher m = p.matcher("aaaaab"); boolean b = m.matches(); Die drei letzten Zeilen lassen sich zusammenfassen zu: boolean b = Pattern.matches("a*b","aaaaab"); Die Matcher-Klasse Die Eingabe an einen Matcher muss dem Interface CharSequence genügen. Im obigen Beispiel wurde ein String-Objekt übergeben. Beispielsweise implementieren String, StringBuffer und CharBuffer dieses Interface. Wichtige Methoden: – boolean matches(): Vergleicht den gesamten Input gegen das Pattern und liefert true, bei ¨ Übereinstimmung, false sonst. – boolean lookingAt() gibt true zurück, wenn das Muster auf den Anfang des Textstrings passt, anderenfalls false. – boolean find(): Scanned die eingegebene Zeichenfolge und sucht die nächste Teilfolge, die mit dem Pattern übereinstimmt. – boolean find(int start): Setzt den Matcher und versucht die nächste Teilzeichenfolge der Eingabesequenz zu finden, die zum Muster passt. Start ist der spezifizierte Index. – int start() gibt nach einem erfolgreichen Match den Index des ersten Zeichens zurück, das gematcht wurde – int start(group) gibt den Startindex der Teilzeichenfolge zurück, die durch die gegebene Gruppe während der vorhergehenden Operation eingefangen wurde – int end() gibt nach einem erfolgreichen Match den Index des letzten Zeichens zurück, das gematcht wurde. Falls kein Match versucht wurde bzw. kein Match erfolgreich war, werfen start() und end() eine IllegalException aus. Dies ist eine RunTimeException, die nicht aufgefangen werden kann. – int end(int group) gibt das Offset nach dem letzten Zeichen der Teilzeichenfolge zurück, die von der gegebenen Gruppe während der vorhergehenden Operation eingefangen wurde. – Matcher appendReplacement(StringBuffer sb,String replacement): implementiert einen nicht begrenzten "anhängen-und-ersetzen"-Schritt. – String replaceAll(replacement): ersetzt jede Teilzeichenfolge der Eingabe, die das Pattern durch das gegebene replacement ersetzt – replaceFirst(replacement): ersetzt die erste Teilzeichenfolge der Eingabe, die mit dem Muster übereinstimmt, durch pattern. Bsp. 112: import java.util.regex.*; public class Replacement { public static void main(String[] args) throws Exception { // Create a pattern to match cat Pattern p = Pattern.compile("cat"); 112 pr31250 172 Algorithmen und Datenstrukturen // Create a matcher with an input string Matcher m = p.matcher("one cat," + " two cats in the yard"); StringBuffer sb = new StringBuffer(); boolean result = m.find(); // Loop through and create a new String // with the replacements while(result) { m.appendReplacement(sb, "dog"); result = m.find(); } // Add the last segment of input to // the new String m.appendTail(sb); System.out.println(sb.toString()); } } – String group(): liefert die Eingabefolge (String), die von dem vorhergehenden Match bestimmt wurde. – String group(int group): liefert die Eingabefolge (String) zurück, die von der angebenen Gruppe während der vorhergehenden Operation eingefangen wurde. 173 Algorithmen und Datenstrukturen 3.2 Entwurfstechniken Algorithmen-Mustern) für Algorithmen (Einsatz von Wie findet man für ein gegebenes Problem einen Algorithmus bzw. einen guten Algorithmus? Für dieses Problem gibt es leider keinen allgemeingültigen Algorithmus. Manche Algorithmen sind aber von ihrer Grundkonzeption her ähnlich. Man betrachtet eine Auswahl solcher häufig wiederkehrender Techniken für den Algorithmenentwurf und versucht folgende Idee zu realisieren: Anpassung von generischen Algorithmenmustern für bestimmte Problemklassen an eine konkrete Aufgabe. 3.2.1 Greedy Algorithmen Ein greedy algorithm ist ein Algorithmus, der sich in jedem Schritt ein lokales Optimum aussucht, was dann im Endeffekt zum globalen Optimum führt (und damit zum Erfolg des Algorithmus). Ein einführendes Beispiel. Auf Geldbeträge unter 1 DM soll Wechselgeld herausgegeben werden. Zur Verfügung stehen ausreichend Münzen mit den Werten 50, 10, 5, 2, 1 Pfennig. Das Wechselgeld soll aus so wenig Münzen wie möglich bestehen. Also: 50 + 2 * 10 + 5 + 2 + 1. Der Greedy-Algorithmus bestimmt: Nimm jeweils die größte Münze unter Zielwert, und ziehe sie von diesem ab. Verfahre derart bis Zielwert gleich Null. Greedy-Algorithmen berechnen lokales Optimum, z.B.: Münzen 11, 5 und 1; Zielwert 15. Greedy: 11 + 1 + 1 + 1 + 1 Optimum: 5 + 5 + 5 Aber in vielen Fällen entsprechen lokale Optima den globalen bzw. reicht ein lokales Optimum aus. Gierige Algorithmen. Das (Optimierungs-) Problem wird in einzelne Schritte zerlegt. In jedem Schritt wird "gierig" die kurzfristig (lokal) optimale Lösung gewählt. Aus diesen Einzelschritten ergibt sich die Gesamtlösung 113. Bsp. für gierige Algorithmen: Algorithmus von Dijkstra 114, Minimaler spannender Baum (Algorithmus von Prim) 115. Eigenschaften von Greedy-Algorithmen: 1. Gegebene Menge Werte von Eingabewerten 2. Menge von Lösungen, die aus Eingabewerten aufgebaut sind 113 Nicht jedes Problem lässt sich mit einem gierigen Algorithmus lösen. Lösungen, bei denen zunächst ein (kleiner) Nachteil in Kauf genommen werden muß, um später einen (größeren) Vorteil zu erlangen, findet man nicht mit einem gierigen Algorithmus 114 In jedem Schritt wird gierig aus den noch nicht besuchten Knoten jener augewählt, der die geringste Entfernung zum Startknoten besitzt. 115 In jedem Schritt wird gierig die kürzeste Kante vom Baum zu einem Knoten gewählt, der sich noch nicht im Baum befindet. 174 Algorithmen und Datenstrukturen 3. Lösungen lassen sich schrittweise aus partiellen Lösungen, beginnend bei der leeren Lösung, durch Hinzunahme von Eingabewerten aufbauen 4. Bewertungsfunktion für partielle und vollständige Lösungen 5. Gesucht wird die / eine optimale Lösung 3.2.1.1 Greedy-Algorithmen für minimale Spannbäume Gegeben: Ungerichteter, zusammenhängender kantenbewerteter Graph G = (V , E ) Gesucht minimaler Spannbaum (minimum spanning tree) des ungerichteten Graphen mit - T ⊂ E (der minimale Spannbaum ist Teilgraph von G - (V , T ) ist ungerichteter Baum (zusammenhängend, kreisfrei) - Summe der Kantenlängen von (V , T ) hat den kleinstmöglichen Wert. Demonstrationsgraph: 1 2 1 4 2 5 3 4 4 5 6 5 6 3 8 7 3 4 7 1. Algorithmus von Prim Zugrundeliegende (algorithmische) Idee: Minimaler Spannbaum wird beginnend mit willkürlich gewählter Wurzel zusammenhängend aufgebaut. Prim-Algorithmus in Struktogrammdarstellung 175 Algorithmen und Datenstrukturen Eingabe Knoten, Kanten, Gewichte Initialisiere Menge B mit einem beliebig gewählten Element von V (B: Wurzelknoten des aufzubauenden minimalen Spannbaums) T=0 (u,v): kürzeste noch verfügbare Kante mit u ∈ V\B und v ∈ B (greedy!) T = T ∪ {(u,v)} B = B ∪ {u} Lösche (u,v) B == V Ausgabe: T Abarbeitungsprotokoll des Prim-Algorithmus: Greedy-Schritt 0 1 2 3 4 5 6 V\B {2,3,4,5,6,7} {3,4,5,6,7} {4,5,6,7} {5,6,7} {6,7} {6} 0 B 116 {1} {1,2} {1,2,3} {1,2,3,4} {1,2,3,4,5} {1,2,3,4,5,7} {1,2,3,4,5,6,7} (u,v) (2,1) (3,2) (4,1) (5,4) (7,4) (6,7) T 0 {(2,1)} {(2,1),(3,2)} {(2,1),(3,2),(4,1)} {(2,1),(3,2),(4,1),(5,4)} {(2,1),(3,2),(4,1)},(5,4),(7,4)} {(2,1),(3,2),(4,1),(5,4),(7,4),(6,7) } 2. Algorithmus von Kruskal Zugrundeliegende (algorithmische) Idee: - - 116 Alle ungerichteten Kanten des gegebenen Graphen werden nach aufsteigender Reihenfolge geordnet. Der minimale Spannbaum wird sequentiell aus Teilbäumen aufgebaut. Begonnen wird mit Startbäumen, die jeweils aus einem Knoten bestehen. Zwei Startbäume, die mit dem Endknoten einer kürzesten Kante (greedy!) übereinstimmen, werden mit den Kanten zu einem Teilbaum (minmaler Länge) über zwei Knoten verbunden. In den nachfolgenden Verbindungsschritten werden jeweils zwei der vorhandenen Teilbäume durch eine noch nicht eingebaute kürzeste Kante (greedy) zu einem Teilbaum (minimaler Länge) mit größerer Knotenanzahl verbunden, wenn der Endknoten dieser Kante in verschiedenen Teilbäumen liegen. Ist das nicht der Fall, scheidet diese Kante endgültig aus dem Verfahren aus (Kreisfreiheit!). Die Vorgehensweise wird erschöpfend angewandt. Das Verfahren hält an, wenn so alle Knoten zu einem Baum verbunden sind. Dieser ist dann ein minimaler Spannbaum des gegebenen Graphen. Menge der besuchten Knoten 176 Algorithmen und Datenstrukturen Kruskal-Algorithmus in Struktogrammdarstellung Eingabe: Knoten und Kanten einschl. Gewichte Ordne alle Kanten nach aufsteigender Länge Initialisiere n Mengen (Knotenmenge er Teilbäume) mit je einem Element von V. T=0 (u,v): kürzeste noch verfügbare Kante ucomp: Menge, die u enthält vcomp: Menge, die v enthält nein vcomp == ucomp ja mische(ucomp,vcomp) { vereinige die disjunkten Mengen ucomp und vcomp lösche danach ucomp und vcomp } T = T {(u,v)} Lösche (u,v) card(T) = n 117 - 1 Ausgabe: T Abarbeitungsprotokoll des Kruskal-Algorithmus 118: Greedy- Mengen 119 Schritt 0 (Init.) {1},{2},{3},{4},{5},{6},{7 } 1 {1,2},{3},{4},{5},{6},{7} 2 {1,2,3},{4},{5},{6},{7} 3 {1,2,3},{4},{5},{6},{7} 4 {1,2,3},{4,5},{6,7} 5 {1,2,3,4,5},{6,7} 6 {1,2,3,4,5},{6,7} 7 {1,2,3,4,5,6,7} (u,v) ucomp vcomp T 0 (1.2) (2,3) (4,5) (6,7) (1,4) (2,5) (4,7) {1} {1,2} {4} {6} {1,2,3} {1,2,3,4,5} 120 {1,2,3,4,5} Implementierung: vgl. Kruskal.java 121 117 Anzahl der Knoten im Graphen vgl. 5.6.2 119 Knotenmenge der Teilbäume 120 nicht disjunkt 121 pr56200 118 177 {2} {3} {5} {7} {4,5} {1,2,3,4,5} {6,7} {(1,2)} {(1,2),(2,3)} {(1,2),(2,3),(4,5)} {(1,2),(2,3),(4,5),(6,7)} {(1,2),(2,3),(4,5),(6,7),(1,4)} {(1,2),(2,3),(4,5),(6,7),(1,4)} {(1,2),(2,3),(4,5),(6,7),(1,4),(4,7) } Algorithmen und Datenstrukturen 3.2.1.2 Huffman Codes Definition. Der Huffman-Algorithmus erzeugt einen Binärcode für eine gegebene Zeichenmenge gemäß der Häufigkeit jedes einzelnen Zeichens in einem Text. Je öfter ein Zeichen auftritt, desto kürzer ist die ihm entsprechende Bitfolge. In diesem Sinne liefert der Algorithmus einen optimalen Code. Bsp.: Codeworte fester Länge bei der Binärcodierung von Zeichen. In einer Textdatei befinden sich bspw. die Zeichen „a“, „e“, „i“, „s“, „t“ und die Zeichen „space“ bzw. „newline“. Die folgende Tabelle zeigt, in welcher Häufigkeit diese Zeichen in der Textdatei vorkommen: Zeichen (Character) a e i s t space newline Häufigkeit 10 15 12 3 4 13 1 Würde man diese Zeichen mit einem Binärcode fester Länge verschlüsseln, dann könnte dies auf folgende Weise bspw. geschehen: Zeichen (Character) a e i s t space newline Summe Code 000 001 010 011 100 101 110 Häufigkeit 10 15 12 3 4 13 Anzahl Bits 30 45 36 9 12 39 3 174 Abb. Standard zur Binärcodierung von Zeichen Bei größeren Dateien führt diese Art der Binärcodierung zur erheblichem Platzbedarf. Besser wäre eine Codierung, die angepasst an die Häufigkeit von Vorkommen der Zeichen, für die einzelnen Zeichen Codeworte variabler Länge vorsieht. Ein besonders häufig vorkommendes Zeichen, erhält ein kurzes Codewort. Ein weniger häufig vorkommendes Zeichen erhält ein längeres Codewort zugeordnet. Der Algorithmus von Huffman. Zu Beginn liegen die einzelnen Zeichen mit ihren Häufigkeiten in der folgenden Form vor: 10 a 15 e 12 i 3 s 4 t 13 sp 1 nl Die beiden Knoten(Bäume) mit den niedigsten Gewichtswerten (Häufigkeiten) werden zusammengefasst: 178 Algorithmen und Datenstrukturen 10 a 15 12 e i 4 13 t 4 sp T1 s nl Abb. Huffman Algorithmus nach dem ersten Mischen Die beiden Bäume mit dem kleinsten Gewicht wurden zusammengemischt. Das Gewicht des neuen Baums entspricht der Summe der Gewichte der alten Bäume. 10 a 15 12 e i 13 8 sp T2 t T1 s nl Abb. Huffman Algorithmus nach dem zweiten Mischen 15 e 12 i 13 18 sp T3 a T2 t T1 s nl Abb. Huffman Algorithmus nach dem dritten Mischen Es gibt jetzt vier Bäume, aus denen die beiden Bäume mit dem kleinsten Gewicht gewählt werden. 179 Algorithmen und Datenstrukturen 15 25 e 18 T4 i T3 sp a T2 t T1 s nl Abb. Huffman Algorithmus nach dem vierten Mischen Im fünften Schritt werden die Bäume mit den Wurzeln „e“ und „T3“ gemischt, da sie jetzt die kleinsten Gewichte haben. 25 33 T4 i T5 sp e T3 a T2 t T1 s Abb. Huffman Algorithmus nach dem fünften Mischen 180 nl Algorithmen und Datenstrukturen 58 T6 T4 T5 e T3 sp a T2 t T1 s i nl Abb. Huffman Algorithmus nach Erreichen des optimalen Baums Für die Codierung der Zeichen steht der folgende optimale Präfix-Code bereit: 0 0 1 1 0 e 0 i 1 sp 1 a 0 1 t 0 s 1 nl Abb. Optimaler Präfix-Code Die Tabelle für die Codierung der Zeichen im vorliegenden Beispiel hat folgende Gestalt: 181 Algorithmen und Datenstrukturen Zeichen A E I S T Space Newline Summe Code 001 01 10 00000 0001 11 00001 Häufigkeit 10 15 12 3 4 13 1 Anzahl Bits 30 30 24 15 16 26 5 146 Abb. Optimaler Präfix-Code für das vorliegende Beispiel Die Codierung benutzt nur 146 Bits. Der Huffman-Algorithmus ist ein Greedy-Algorithmus. Auf jeder Ebene wird ein Mischvorgang ausgeführt ohne Rücksicht auf globale Betrachtungen. Gemischt werden lokal die Bäume mit den kleinsten Gewichtswerten. Das Gewicht eines Baums ist gleich der Summe der Häufigkeiten von seinen Blättern bzw. Teilbäumen. Damit kann der Algorithmus folgendermaßen formuliert werden: - Wähle die beiden Bäume T1 und T2 mit dem kleinsten Gewicht aus und bilde daraus einen neuen Baum mit den Teilbäumen T1 und T2. - Zu Beginn gibt es nur Bäume, die aus einzelnen Knoten bestehen. Jeder Knoten besteht steht für ein einzelnes Zeichen. - Am Ende gibt es nur einen einzigen Baum und das ist der optimale Baum mit dem Huffman-Code. Aufwand. Werden die Bäume in einer Priority-Queue verwaltet, dann beträgt die Laufzeit O(C 122logC). Wird die Priority-Queue einfach in einer verketteten Liste implementiert, dann beträgt die Laufzeit O(C2) Zu dieser Aufwandsgröße muß noch der Aufwand zur Ermittlung der Häufigkeit der Zeichen addiert werden. Java-Implementierung. Der Huffman-Algorithmus kann zur Verdichtung bzw. Kompression von zu speichernden Daten verwendet werden. Für diese Aufgaben existieren in Java die Klassen - Deflater: zur Kompression eines Datenstroms nach einem wählbaren Verfahren - Inflater: zur Dekompression eines Datenstroms der zuvor mit Deflater komprimiert wurde unter Verwendung desselben Ver-/Entschlüsselungsverfahrens. Die Deflater-Klasse hat folgende Methoden: deflate() end() finalize() finish() finished() needsInput() reset() getAdler() getTotalIn() 122 liefert den komprimierten Datenstrom zurück gibt alle intern benötigten Ressourcen frei schließt die Deflater-Zustände ab und wird durch die JVM aufgerufen zeigt das Ende dernoch nicht komprimierten daten an bestimmt, ob noch nicht komprimierte Daten verfügbar sind prüft, ob der Eingabepuffer leer ist stellt den Deflater wieder auf den Anfangszustand gibt die Checksumme der nicht komprimierten Daten an gibt die Anzahl (noch) nicht komprimierter Daten in Bytes an C ist die Anzahl der Zeichen. 182 Algorithmen und Datenstrukturen getTotalOut() setInput() setLevel() setStrategy() setDictionary gibt die Anzahl komprimierter Daten in Bytes an stellt die zu komprimierenden Daten bereit legt das Komprimierungsniveau fest setzt die Komprimierungsstrategie fest definiert ein Dictionary-feld zur Unterstütung der Kompression Darüber hinau besitzt die Deflater-Klasse "Field-Größen" zur Festlegung der Komprimierungen: BEST_COMPRESSION, BEST_SPEED, FILTERED, HUFFMAN_ONLY DEFAULT_COMPRESSION, NO_COMPRESSION, Bsp. 123: Kompremierung einer Datei mit Anzeige des Komprimierungsergebnisses (Byteanzahl, Checksumme) 123 vgl.pr33120 183 Algorithmen und Datenstrukturen 3.2.2 Divide and Conquer Typisches Beispiel. Quicksort Prinzip. Rekursive Rückführung auf identisches Problem mit kleiner Eingabemenge. Divide-and-Conquer-Algorithmen arbeiten grundsätzlich so: Teile das gegebene Problem in mehrere getrennte Teilprobleme auf, löse diese einzeln und setze die Lösungen des ursprünglichen Problems aus den Teillösungen zusammen. Wende dieselbe Technik auf jedes der Teilprobleme an, dann auf deren Teilprobleme usw. bis die Teilprobleme klein genug sind, dass man eine Lösung explizit angeben kann. Trachte danach, dass jedes Teilproblem derselben Art ist wie das ursprüngliche Problem, so dass es mit demselben Algorithmus gelöst werden kann. Weitere Beispiele für Divide and Conquer. 1. Merge-Sort 2. Türme von Hanoi 3.2.3 Induktiver Algorithmenentwurf und Dynamisches Programmieren Induktiver Algorithmenentwurf - Für kleinere Problemgrößen erfolgt eine direkte Problemlösung Zur Lösung eines Problem der Größe n, geht man davon aus: Die Lösung des Problems der Größe n – 1 ist bekannt. Alternative: Zur Lösung eines Problems der Größe n, geht man davon aus, dass Lösungen von Problemen der Größe 1, 2, 3, ... , n-1 bekannt sind. Bsp.: Berechnung von Fibonacci-Zahlen (Ineffizienter rekursiver Algorithmus 124). public static int fibrek(int n) { if (n <= 1) return 1; else return fibrek(n - 1) + fibrek(n -2); } Diese so elegant aussehende Lösung ist furchtbar schlecht. Sie benötigt eine Laufzeit T(N) >= T(N-1) + T(N-2). Da T(N) die gleiche rekurive Beziehung besitzt wie Fibonacci-Zahlen, wächst T(N) genauso wie Fibonacci-Zahlen wachsen, d.h. exponentiell. Eine Protokollierung der rekursiven Aufrufe für fibrek(6) zeigt dies: 124 pr32301 184 Algorithmen und Datenstrukturen fibrek(6) fibrek(5) fibrek(4) fibrek(4) fibrek(3) fibrek(3) fibrek(2) fibrek(3) fibrek(2) fibrek(1) fibrek(2) fibrek(2) fibrek(1) fibrek(1) fibrek(0) fibrek(2) fibrek(1) fibrek(1) fibrek(0) fibrek(1) fibrek(0) fibrek(1) fibrek(0) fibrek(1) fibrek(0) Dynamisches Programmieren Schrittweise werden alle Problemgrößen von der kleinsten bis zur gesuchten gelöst. Die Lösungen der kleineren Pobleme werden zwischengespeichert, falls man die Lösung eines kleineren Problems zur Lösung eines größeren benötigt, wird die bereits ermittelte Lösung einfach nachgeschlagen. Bsp.: Man beobachtet bei der Berechnung der Fibonacci-Zahlen: FN-1 wird nur einmal aufgerufen, aber FN-2 wird zweimal, FN-3 wird dreimal, FN-4 wird viermal, FN-5 wird fünfmal berechnet, usw. Zur Berechnung von FN wird aber lediglich die Berechnung von FN-1 und FN-2 benötigt. Man braucht sich dabei nur auf die aktuell errechneten Werte zu beziehen. Das führt zu dem folgenden Algorithmus 125 mit dem Aufwand O(N). public static int fibit(int n) { if (n <= 1) return 1; int letzterWert = 1; int vorletzterWert = 1; int resultat = 1; for (int i = 2;i <= n; i++) { resultat = letzterWert + vorletzterWert; vorletzterWert = letzterWert; letzterWert = resultat; } return resultat; } Generell bietet sich dynamisches Programmieren an, wenn man zur Lösung eines Problems das Problem in Teilprobleme zerlegt, um die Gesamtlösung aus den Teillösungen zusammenzusetzen, und die Teilprobleme nicht wie bei divide-andconquer unabhängig sind. Bei der dynamischen Programmierung speichert man bereits berechnete Lösungen in einer Tabelle ab, um Mehrfachberechnungen zu vermeiden. Das erhöht den Speicheraufwand. 125 pr32301 185 Algorithmen und Datenstrukturen 3.3 Rekursion Viele Probleme beschreiben eine rekursive Struktur. Für sie können häufig rekursive Lösungen elegant formuliert werden: - Berechnung rekursiv defilnierter mathematischer Funktionen Überprüfung der Syntax von Ausdrücken Operationen auf rekursiv definierten Datenstrukturen Rekursive Formulierungen sparen explizit Laufvariablen und Kontrollstruikturen. Rekursive Aufrufe verbrauchen Speicher auf dem Stack, es sei denn, es handelt sich um Endrekursion, die von modernen Compilern optimiert wird. 3.3.1 Linear rekursive Funktionen Eine Funktion heißt linear rekursiv, wenn die Ausführung der Funktion zu höchstens einem rekursiven Aufruf der Funktion führt. Linear rekursive Funktionen können endrekursiv sein. Endrekursive Funktionen: Eine rekursive Funktion heißt endrekursiv, wenn sie linear ist und jede Ausführung der Funktion entweder nicht zu einem rekursiven Aufruf führt oder das Ergebnis des rekursiven Aufrufs gleich dem Ergebnis der Funktion ist. Eine endrekursive Funktion heißt schlicht, wenn der rekursive Aufruf direkt (ohne nachfolgende Operation) den Funktionswert liefert. Eine rekursive Funktion ist endrekursiv, wenn alle rekursiven Aufrufe schlicht sind. Bsp.: Die Fakultätsfunktion ist endrekursiv. Schema zur Entrekusivierung endrekursiver Funktionen. Prinzipiell gilt: Alle Aufgaben, die mit einer Iteration lösbar sind, sind auch ohne Schleifen durch Rekursion lösbar. Rekursionen kann man meistens mit Hilfe von Iterationen simulieren. Oft sind rekursive Lösungen einfacher zu verstehen, verbrauchen aber für die Abarbeitung mehr Speicherplatz. endrekuriv iterativ einTyp pRekursiv(... x ...) { .... if (condition(x)) { /* S1; */ // Anweisungen return pRekursiv(f(x)); } else { /* S2; */ // Anweisungen return g(x); } } einTyp pIterativ(… x …) { ... while(condition(x)) { /* S1; */ x = f(x); } /* S2; */ // Anweisungen return g(x); } 186 Algorithmen und Datenstrukturen 3.3.2 Nichtlineare rekursive Funktionen Eine rekursive Funktion heißt nichtlinear rekursiv, wenn die Ausführung der Funktion zu mehr als einem rekursiven Aufruf führt. Bsp.: Die Fibonacci-Funktion 126 ist nichtlinear rekursiv. 3.3.3 Primitive Rekursion Eine rekursive Funktion ist primitiv rekursiv, wenn der rekursive Aufruf nicht geschachtelt ist 3.3.4 Nicht primitive Rekursion Eine rekursive Funktion ist nicht primitiv rekursiv, wenn der rekursive Aufruf geschachtelt ist. Bsp.: Die Ackermann-Funktion Die Rekursion eignet sich für die Definition von Funktionen, die sehr schnell wachsen. So ist die Ackermann-Funktion 127 ein Beispiel für eine Rekursion, die nicht (oder zumindest nicht direkt) durch Iteration ersetzt werden kann. Die Werte der Ackermann-Funktion (mit zwei Argumenten n und m) sind durch die folgenden Formeln definiert: a m0 = m + 1 a 0n = a1n −1 a mn = a ann−1 m −1 Die Ackermann-Funktion wächst stärker als jede primitiv rekursive Funktion. /* * Acker.java */ public class Acker { static int a(int x, int { if (x == 0) return y + if (y == 0) return a(x return a(x - 1,a(x,y } y) 1; - 1,1); 1)); public static void main(String args[]) { int x = Integer.parseInt(args[0]); int y = Integer.parseInt(args[1]); System.out.println(a(x,y)); } } 126 127 vgl. 1.2.1.5.1 bzw. 3.2.3 Benannt nach dem Mathematiker F.W. Ackermann, 1896 - 1962 187 Algorithmen und Datenstrukturen 3.3.5 Rekursive Kurven Das Wesen der Rekursion – insbesondere der Selbstähnlichkeit – kann mit Hilfe von Monsterkurven demonstriert werden. Sie sind eindimensionale geometrische Gebilde unendlicher Länge, die eine Fläche abdecken. Monsterkurven werden nach einem regelmäßigen Muster schrittweise verfeinert. Sie errinnern an Formen, die mit Hilfe von Fraktalen erstellt werden können. Die Rekursion ist geeignet, die unendlich lange Monsterkurve mit endlich langen Kurven anzunähern. Solche Annäherungen einer Monsterkurve kann man als rekursive Kurve bezeichnen. Anweisungen für eine Monsterkurve können folgendermaßen formuliert werden: 1) Man nehme einen Initiator. Das kann eine einzelne Strecke sein, kann aber auch aus mehreren Liniensegmenten bestehen. 2) Man nehme einen Generator, der den Wachstumsprozeß des Monsters festlegt. Der Generator besteht aus mehreren Teilstrecken sowie einem Start- und einem Endpunkt. Im ersten Konstruktionsschritt (1. Rekursionsstufe) werden die Initiator-Segmente durch den Generator ersetzt. Der Generator wird dabei so gedreht und skaliert, daß seine Begrenzungspunkte mit der Initiator-Strecke zusammenfallen. Gibt es mehrere Initiator-Strecken, dann entstehen auch mehrere Generatoren. In der zweiten Rekursionsstufe wird jedes einzelne Segment wiederum durch den Generator ersetzt. Diesen Prozeß wiederhölt man so oft, bis das Fraktal (die Monsterkurve) die gewünschte Einheit zeigt. Zum Zeichnen von rekursiven Kurven wird die Technik der Turtle-Grafik 128 herangezogen. Die Turtle (Grafik-Cursor) bewegt sich folgendermaßen über die Ebene: a) geradeaus in einem Schritt. Nach dem Arbeitsgang werden die neu berechneten Kordinaten der Turtle bereitgestellt. b) Wende über eine Drehung um einen bestimmten Winkel. Der Drehwinkel wird als Parameter im Aufruf übergeben. Beispiele. 1. Die Schneeflockenkurve (Kochsche Kurve) Ausgangspunkt ist eine Gerade (Initiator). 128 Am MIT wurde die Turtle-Grafik erfunden 188 Algorithmen und Datenstrukturen Abb.: Schneeflockenkurve auf der Stufe 0 Diese Strecke wird in drei gleiche Teile unterteilt, und das Mittelstück durch 2 Seiten eines gleichseitigen Dreiecks ersetzt. Abb.: Schneeflockenkurve auf der Stufe 1 Im nächsten Schritt wird jede der vier Strecken des Generators, allerdings auf ein Drittel seiner Größe reduziert, ersetzt. 189 Algorithmen und Datenstrukturen Abb.: Schneeflockenkurve auf der Stufe 2 Die Prozedur für den Initiator umfaßt hie nur das Zeichnen der geraden Strecke. Entscheidend ist der Generator. Hier wandert der Grafik-Cursor (die Turtle) zunächst geradeaus (ein Drittel der vorhergehenden Stufe), wendet sich dann um 60 Grad nach links, dann 120 Grad nach rechts, usw. (vgl. Abb.). Das wird auf den weiteren Stufen fortgesetzt und führt zu einem allgemeinen Bildungsgesetz einer rekursiven Prozedur mit zwei Parametern im rekursiven Aufruf: „stufe – 1“, „laenge/3“. public void schneeflocke(int stufe,int laenge) { double xAlt, yAlt; if (stufe == 0) { xAlt = turtle.holeTurtleX(); // System.out.println(xAlt); yAlt = turtle.holeTurtleY(); // System.out.println(yAlt); turtle.setzeTurtleR(laenge); turtle.schritt(); grafKontext.drawLine((int) xAlt, (int) yAlt, (int) turtle.holeTurtleX(), (int) turtle.holeTurtleY()); } else { schneeflocke(stufe-1,laenge/3); turtle.wende(-60); schneeflocke(stufe-1,laenge/3); turtle.wende(120); schneeflocke(stufe-1,laenge/3); turtle.wende(-60); schneeflocke(stufe-1,laenge/3); } } 2. Die Drachenkurve Faltet man einen Papierstreifen doppelt in der Mitte und öffnet ihn dann so, daß sich rechte Winkel bilden, dann erhält man – von der Seite gesehen – die zweite Stufe der Drachenkurve. 190 Algorithmen und Datenstrukturen Abb.: Stufe 2 der Drachenkurve Der Initiator ist wieder die Einheitsstrecke, der Generator besteht aus zwei rechten Winkeln. Abb.: Stufe 3 der Drachenkurve Es ist zwischen Links- und Rechtsorientierung zu unterscheiden (Parameter Orientierung). Im weiteren Verlauf (Stufe 15) führt das zu folgendem Bild: 191 Algorithmen und Datenstrukturen Abb.: Stufe 15 der Drachenkurve Die folgende rekursive Prozedur 129 ermöglicht das Zeichnen der vorliegenden Drachenkurven: public void drache(int stufe,double laenge,boolean richtung) { double wurzelZwei = Math.sqrt(2); double xAlt, yAlt; if (stufe == 0) { xAlt = turtle.holeTurtleX(); // System.out.println(xAlt); yAlt = turtle.holeTurtleY(); // System.out.println(yAlt); turtle.setzeTurtleR(laenge); turtle.schritt(); grafKontext.drawLine((int) xAlt, (int) yAlt, (int) turtle.holeTurtleX(), (int) turtle.holeTurtleY()); } else { final int gradLinks = 45 * (richtung ? 1 : -1); final int gradRechts = 90 * (richtung ? -1 : 1); turtle.wende(gradLinks); drache(stufe-1,laenge/wurzelZwei,true); turtle.wende(gradRechts); drache(stufe-1,laenge/wurzelZwei,false); turtle.wende(gradLinks); } } 129 pr33201 192 Algorithmen und Datenstrukturen 3.4 Backtracking-Algorithmen Bei manchen Problemen kann nicht mit Sicherheit bestimmt werden, welcher der möglichen nächsten Schritte zum (optimalen) Ziel führt. Prinzipiell muß man alle möglichen Schritte der Reihe nach ausprobieren, um festzustellen, ob sie zu einer Lösung (zur optimalen Lösung) führen. Falls erkannt wird, dass ein Schritt nicht zielführend ist, wird er rückgängig gemacht. Backtracking ist eine systematische Art der Suche (Tiefensuche) in einem vorgebenen Suchraum. Wenn eine Teillösung in eine Sackgasse führt, dann wird jeweils der letzte Schritt rückgängig gemacht. Das Rückgängigmachen eines Schritts nennt man Back-tracking, daher der Name Backtracking. Allgemeiner Backtracking Algorithmus boolean findeLoesung(int index, Lsg loesung, ...) { // index ist die aktuelle Schrittzahl // Teilloesungen werden als Referenz uebergeben 1. Solange es noch neue Teil-Loesungsschritte gibt: a) Waehle einen neuen Teil-Lösungsschritt b) Falls schritt gueltig ist I) Erweitere loesung um schritt II) Falls loesung vollstaendig ist, return true, sonst: if (findeLoesung(index+1,loesung) { return true; // Loesung gefunden } else { // Sackgasse Mache schritt rueckgaengig; // Backtracking } 2. Gibt es keinen neuen Teil-Loesungsschritt mehr, so: return false; } In Java-Pseudocode lässt sich der allgemeine Backtracking Algorithmus so formulieren: boolean findeLoesung(int index, Lsg loesung, ...) { // index ... Schrittzahl // loesung . Referenz auf Teilloesung while (es_gibt_noch_neue_Teil-Loesungsschritte) { waehle_einen_neuen_Teilloesungsschritt; if (schritt_ist_gueltig) { erweitere_loesung_um_schritt if (loesung_noch_nicht_vollstaendig) { // rekursiver Aufruf von findeLoesung if (findeLoesung(index + 1,loesung,...) return true; // Loesung gefunden else { // Sackgasse mache_Schritt_rueckgaengig; // Backtracking } } else return true; // Loesung gefunden -> fertig } } return false; } // falls true Rueckgabewert steht die Loesung in loesung 193 Algorithmen und Datenstrukturen Backtracking ist Tiefensuche, z.B. in einem Labyrinth. Der Lösungsprozeß wird in einzelne Schritte aufgeteilt. In jedem Schritt öffnet sich eine endliche Zahl von Alternativen. Einige führen in eine Sackgasse, andere werden nach demselben Verfahren überprüft. Ergebnisse können Erfolg und Misserfolg zeigen (Trial and Error). Die Lösungsstrategie führt zwar theoretisch zum Ziel, allerdings kann die Anzahl der zu untersuchenden Alternativen derart groß werden, dass die Lösungen nicht meht in zumutbarer Zeit ermittelt werden können. Die folgende Darstellung zeigt ein Labyrinth. In diesem Labyrinth soll ein Weg vom Start- zum Zielpunkt gefunden werden. Die Lösung dieses Problems ist eine Anwendung der vorstehenden Prozedur in Java-Pseudocode boolean findeLoesung(int index,Lsg loesung, int aktX, int aktY) mit [aktX][aktY] zur Angabe der aktuellen Feldposition. „findeLoesung() 130“ findet in einem Labyrinth mit K x L Feldern eine Weg vom Start zum Ziel und benutzt dabei die folgende Lösungsstrategie: - Systematische Suche vom aktuellen Feld im Labyrinth 1. oben, 2. rechts, 3. unten, 4. links - Markierung besuchter Felder - Zurücknahme der Züge in Sackgassen (Backtracking) Das Resultat soll in einem zweidimensionalen Array loesung.feld[][] stehen. Den Feldwert loesung.feld[x][y] an der Position [x][y] definiert man als -1, wenn das Feld als Sackgasse erkannt wurde. 0, wenn das Feld besucht wurde > 0, wenn das Feld zum Lösungsweg gehört. 130 vgl. pr32410, Labyrinth 194 Algorithmen und Datenstrukturen Abb. Die Feldwerte des Lösungsweges geben die Besuchsreihenfolge wieder. 195 Algorithmen und Datenstrukturen [6][2] [2][5] [6][3] [5][1] [5][3] [6][4] [6][1] [5][4] [6][5] [6][0] [5][5] [6][6] [5][0] [5][6] [4][0] [4][6] [4][1] [3][6] [2][6] [1][6] [0][6] [1][5] [0][5] [2][5] [0][4] [2][4] [0][3] [1][4] [0][2] [1][3] [0][1] [1][2] [2][2] [2][1] [1][1] [0][1] [0][0] Abb. Wege im Labyrinth (Durchlauf durch das Labyrinth) Laufzeit. Bei der Tiefensuche werden bei -max k möglichen Verzweigungen von jeder Teillösung aus und - einem Lösungsbaum mit maximaler Tiefe von n im schlechtesten Fall O(kn) Knoten im Lösungsbaum erwartet. Tiefensuche und somit auch Backtracking haben im schlechtesten Fall mit O(kn) eine exponentielle Laufzeit. Aus der Komplexitätstheorie ist bekannt: Algorithmen mit nicht polynomialer Laufzeit sind zu langsam. Bei Problemen mit großer Suchtiefe wird Backtracking deshalb zu lange brauchen. 196 Algorithmen und Datenstrukturen Backtracking - ist eine systematische Suchstrategie und findet deshalb immer eine optimale Lösung, sofern vorhanden, und sucht höchstens einmal in der gleichen Sackgasse. - ist einfach zu implementieren mit Rekursion. - macht Tiefensuche im Lösungsraum. - hat im schlechtesten Fall eine exponentielle Laufzeit O(kn) und ist deswegen primär nur für kleine Probleme geeignet. - erlaubt Wissen über ein Problem in Form einer Heuristik 131 zu nutzen, um den Suchraum einzuschränken und die Suche dadurch zu beschleunigen. Typische Einsatzfelder des Backtracking: - Spielprogramme (Schach, Dame) - Erfüllbarkeit von logischen Aussagen (logische Programmierspachen) - Planungsprobleme, Konfigurationen. 3.5 Zufallsgesteuerte Algorithmen Zufallsgesteuerte Algorithmen verwenden zufällige Daten, um das Laufzeitverhalten zu verringern. Zufallsgesteuerte Algorithmen sind nicht deterministisch. 131 Damit nicht alle Lösungswege ausprobiert werden müssen, werden Heuristiken verwendet. Das sind Strategien, die mit hoher Wahrscheinlichkeit (jedoch ohne Garantie) das auffinden einer Lösung beschleunigen sollen. 197 Algorithmen und Datenstrukturen 4. Bäume 4.1 Grundlagen 4.1.1 Grundbegriffe und Definitionen Bäume sind eine Struktur zur Speicherung von (meist ganzahligen) Schlüsseln. Die Schlüssel werden so gespeichert, daß sie sich in einem einfachen und effizienten Verfahren wiederfinden lassen. Neben dem Suchen sind üblicherweise das Einfügen eines neuen Knoten (mit gegebenem Schlüssel), das Entfernen eines Knoten (mit gegebenem Schlüssel), das Durchlaufen aller Knoten eines Baums in bestimmter Reihenfolge erklärte Operationen. Weitere wichtige Verfahren sind: - Das Konstruieren eines Baums mit bestimmten Eigenschaften - Das Aufspalten eines Baums in mehrere Teilbäume - Das Zusammenfügen mehrere Bäume zu einem Baum Definitionen Eine Datenstruktur heißt "t-ärer" Baum, wenn zu jedem Element höchstens t Nachfolger (t = 2,3,.... ) festgelegt sind. "t" bestimmt die Ordnung des Baumes (z.B. "t = 2": Binärbaum, "t = 3": Ternärbaum). Die Elemente eines Baumes sind die Knoten (K), die Verbindungen zwischen den Knoten sind die Kanten (R). Sie geben die Beziehung (Relation) zwischen den Knotenelementen an. Eine Datenstruktur D = (K,R) ist ein Baum, wenn R aus einer Beziehung besteht, die die folgenden 3 Bedingungen erfült: 1. Es gibt genau einen Ausgangsknoten (, das ist die Wurzel des Baums). 2. Jeder Knoten (mit Ausnahme der Wurzel) hat genau einen Vorgänger 3. Der Weg von der Wurzel zu jedem Knoten ist ein Pfad, d.h.: Für jeden von der Wurzel verschiedenen Knoten gibt es genau eine Folge von Knoten k1, k2, ... , kn (n >= 2), bei der ki der Nachfolger von ki-1 ist. Die größte vorkommende Pfadlänge ist die Höhe eines Baums. Knoten, die keinen Nachfolger haben, sind die Blätter. Knoten mit weniger als t Nachfolger sind die Randknoten. Blätter gehören deshalb mit zum Rand. Haben alle Blattknoten eines vollständigen Baums die gleiche Pfadlänge, so heißt der Baum voll. Quasivoller Baum: Die Pfadlängen der Randknoten unterscheiden sich höchstens um 1. Bei ihm ist nur die unterste Schicht nicht voll besetzt. Linksvoller Baum: Blätter auf der untersten Schicht sind linksbündig dicht. Geordneter Baum: Ein Baum der Ordnung t ist geordnet, wenn für jeden Nachfolger k' von k festgelegt ist, ob k' der 1., 2., ... , t. Nachfolger von k ist. Dabei handelt es sich um eine Teilordnung, die jeweils die Söhne eines Knoten vollständig ordnet. Speicherung von Bäumen Im allg. wird die der Baumstruktur zugrundeliegende Relation gekettet gespeichert, d.h.: Jeder Knoten zeigt über einen sog. Relationenteil (mit t Komponenten) auf seine 198 Algorithmen und Datenstrukturen Nachfolger. Die Verwendung eines Anfangszeigers (, der auf die Wurzel des Baums zeigt,) ist zweckmäßig. 4.1.2 Darstellung von Bäumen In der Regel erfolgt eine grafische Darstellung: Ein Nachfolgerknoten k' von k wird unterhalb des Knoten k gezeichnet. Bei der Verbindung der Knotenelemente reicht deshalb eine ungerichte Linie (Kante). Abb. 4.1-1: Bei geordneten Bäumen werden die Nachfolger eines Knoten k in der Reihenfolge "1. Nachfolger", "2. Nachfolger", .... von links nach rechts angeordnet. Ein Baum ist demnach ein gerichteter Graf mit der speziellen Eigenschaft: Jeder Knoten (Sohnknoten) hat bis auf einen (Wurzelknoten) genau einen Vorgänger (Vaterknoten). Ebene 1 linker Teilbaum von k Ebene 2 k Ebene 3 Weg, Pfad Ebene 4 Randknoten oder Blätter Abb. 4.1-2: 199 Algorithmen und Datenstrukturen 4.1.3 Berechnungsgrundlagen Die Zahl der Knoten in einem Baum ist N. Ein voller Baum der Höhe h enthält: h (1) N = ∑ t i −1 = i =1 th −1 t −1 Bspw. enthält ein Binärbaum N = 2 h − 1 Knoten. Das ergibt für den Binärbaum der Höhe 3 sieben Knoten. Unter der Pfadsumme Z versteht man die Anzahl der Knoten, die auf den unterschiedlichen Pfaden im vollen t-ären Baum auftreten können: h (2) Z = ∑ i ⋅ t i −1 i =1 Die Summe kann durch folgende Formel ersetzt werden: h⋅ th th −1 Z= − t − 1 ( t − 1) 2 t und h können aus (1) bestimmt werden: t h = N ⋅ ( t − 1) + 1 h = log t ( N ⋅ ( t − 1) + 1) Mit Gleichung (1) ergibt sich somit für Z Z= log t ( N ⋅ ( t − 1) + 1) ⋅ ( N ⋅ ( t − 1) + 1) N ⋅ ( t − 1) ( N ⋅ ( t − 1) + 1) ⋅ log t ( N ⋅ ( t − 1) + 1) − N − = t −1 t −1 ( t − 1) 2 Für t = 2 ergibt sich damit: Z = h ⋅ 2 h − (2 h − 1) bzw. Z = ( N + 1) ⋅ ld ( N + 1) − N Die mittlere Pfadlänge ist dann: (3) Z mit = Z ( N ⋅ ( t − 1) + 1) ⋅ log t ( N ⋅ ( t − 1) + 1) − N ( N ⋅ ( t − 1) + 1) ⋅ log t ( N ⋅ ( t − 1) + 1) 1 − = = N N ⋅ ( t − 1) N ⋅ ( t − 1) t −1 Für t = 2 ist 200 Algorithmen und Datenstrukturen (4) Z mit = Z N +1 = ⋅ ld ( N + 1) − 1 N N Die Formeln unter (3) und (4) ergeben den mittleren Suchaufwand bei gleichhäufigem Aufsuchen der Elemente. Ist dies nicht der Fall, so ordnet man den Elementen die relativen Gewichte gi (i = 1, 2, 3, ... , N) bzw. die Aufsuchwahrscheinlichkeiten zu: N gi , G = ∑ gi pi = G i =1 N Man kann eine gewichtete Pfadsumme Zg = ∑ g i ⋅ hi bzw. einen mitlleren i =1 Suchaufwand ( Z g ) mit = Zg G N = ∑ p i ⋅ h i berechnen. i =1 4.1.4 Klassifizierung von Bäumen Wegen der großen Bedeutung, die binäre Bäume besitzen, ist es zweckmäßig in Binär- und t-äre Bäume zu unterteilen. Bäume werden oft verwendet, um eine Menge von Daten festzulegen, deren Elemente nach einem Schlüssel wiederzufinden sind (Suchbäume). Die Art, nach der beim Suchen in den Baumknoten eine Auswahl unter den Nachfolgern getroffen wird, ergibt ein weiteres Unterscheidungsmerkmal für Bäume. Intervallbäume In den Knoten eines Baumes befinden sich Daten, mit denen immer feinere Teilintervalle ausgesondert werden. Bsp.: Binärer Suchbaum Die Schlüssel sind nach folgendem System angeordnet. Neu ankommende Elemente werden nach der Regel "falls kleiner" nach links bzw. "falls größer" nach rechts abgelegt. 201 Algorithmen und Datenstrukturen 40 30 50 20 11 39 37 24 60 44 40 41 45 62 65 Es kann dann leicht festgestellt werden, in welchem Teilbereich ein Schlüsselwort vorkommt. Selektorbäume (Entscheidungsbäume) Der Suchweg ist hier durch eine Reihe von Eigenschaften bestimmt. Beim Binärbaum ist das bspw. eine Folge von 2 Entscheidungsmöglichkeiten. Solche Entscheidungsmöglichkeiten können folgendermaßen codiert sein: - 0 : Entscheidung für den linken Nachfolger - 1 : Entscheidung für den rechten Nachfolger Die Folge von Entscheidungen gibt dann ein binäres Codewort an. Dieses Codewort kann mit einem Schlüssel bzw. mit einem Schlüsselteil übereinstimmen. Bsp.: "Knotenorientierter binärer Selektorbaum" Folgende Schlüsselfolge wird zum Erstellen des Baums herangezogen: 1710 3810 6310 1910 3210 2910 4410 2610 5310 = = = = = = = = = 0 1 1 0 1 0 1 0 1 1 0 1 1 0 1 0 1 1 0 0 1 0 0 1 1 1 0 0 1 1 0 0 1 1 0 1 0 1 1 1 0 0 0 1 1 12 02 12 12 02 12 02 02 12 Der zugehörige Binärbaum besitzt dann folgende Gestalt: 202 Algorithmen und Datenstrukturen 17 19 0_ 38 39 01_ 32 1_ 63 10_ 11_ 101_ 40 011_ 44 53 110_ In den Knoten dient demnach der Wertebereich einer Teileigenschaft zur Auswahl der nächsten Untergruppe. Knotenorientierte und blattorientierte Bäume Zur Unterscheidung von Bäumen kann auf die Aufbewahrungsstelle der Daten zurückgegriffen werden: 1. Knotenorientierte Bäume Daten befinden sich hier in allen Baumknoten 2. Blattorientierte Bäume Daten befinden sich nur in den Blattknoten Optimierte Bäume Man unterscheidet statisch und dynamisch optimierte Bäume. In beiden Fällen sollen entartete Bäume (schiefe Bäume, Äste werden zu linearen Listen) vermieden werden. Statische Optimierung bedeutet: Der Baum wird neu (oder wieder neu) aufgebaut. Optimalität ist auf die Suchoperation bezogen. Es interessiert dabei das Aussehen des Baums, wenn dieser vor Gebrauch optimiert werden kann. Bei der dynamischen Optimierung wird der Baum während des Betriebs (bei jedem Ein- und Ausfügen) optimiert. Ziel ist also hier: Eine günstige Speicherstruktur zu erhalten. Diese Aufgabe kann im allg. nicht vollständig gelöst werden, eine Teiloptimierung (lokale Optimierung) reicht häufig aus. Werden die Operationen "Einfügen", "Löschen" und "Suchen" ohne besondere Einschränkungen oder Zusätze angewendet, so spricht man von freien Bäumen. Strukturbäume Sie dienen zur Darstellung und Speicherung hierarchischer Zusammenhänge. Bsp.: "Darstellung eines arithmetischen Ausdrucks" Operationen in einem arithmetischen Ausdruck sind zweiwertig (, die einwertige Operation "Minus" kann als Vorzeichen dem Operanden direkt zugeordnet werden). Zu jeder Operation gehören demnach 2 Operanden. Somit bietet sich die Verwendung eines binären Baumes an. Für den arithmetischen Ausdruck (A + B / C)∗ ( D − E∗ F) ergibt sich dann folgende Baumdarstellung: 203 Algorithmen und Datenstrukturen * + - A / B D * E C Abb. 4.1-3: Baumdarstellung des arithmetischen Ausdrucks F (A + B / C)∗ ( D − E∗ F) 4.2 Freie Binäre Intervallbäume 4.2.1 Ordnungsrelation und Darstellung Freie Bäume sind durch folgende Ordnungsrelation bestimmt: In jedem Knoten eines knotenorientierten, geordneten Binärbaums gilt: Alle Schlüssel im rechten (linken) Unterbaum sind größer (kleiner) als der Schlüssel im Knoten selbst. Mit Hilfe dieser Ordnungsrelation erstellte Bäume dienen zum Zugriff auf Datenbestände (Aufsuchen eines Datenelements). Die Daten sind die Knoten (Datensätze, -segmente, -elemente). Die Kanten des Zugriffsbaums sind Zeiger auf weitere Datenknoten (Nachfolger). Dateninformation Schluessel Datenteil Knotenzeiger LINKS RECHTS Zeiger zum linken Sohn Zeiger zum rechten Sohn Abb. 4.2-1: Das Aufsuchen eines Elements im Zugriffsbaum geht vom Wurzelknoten über einen Kantenzug (d.i. eine Reihe von Zwischenknoten) zum gesuchten Datenelement. Bei jedem Zwischenknoten auf diesem Kantenzug findet ein Entscheidungsprozeß über die folgenden Vergleiche statt: 1. Die beiden Schlüssel sind gleich: Das Element ist damit gefunden 2. Der gesuchte Schlüssel ist kleiner: Das gesuchte Element kann sich dann nur im linken Unterbaum befinden 3. Der gesuchte Schlüssel ist größer: Das gesuchte Element kann sich nur im rechten Unterbaum befinden. 204 Algorithmen und Datenstrukturen Das Verfahren wird solange wiederholt, bis das gesuchte (Schlüssel-) Element gefunden ist bzw. feststeht, daß es in dem vorliegenden Datenbestand nicht vorhanden ist. Struktur und Wachstum binärer Bäume sind durch die Ordnungsrelation bestimmt: Aufgabe: Betrachte die 3 Schlüssel 1, 2, 3. Diese 3 Schlüssel können durch verschieden angeordnete Folgen bei der Eingabe unterschiedliche binäre Bäume erzeugen. Stellen Sie alle Bäume, die aus unterschiedlichen Eingaben der 3 Schlüssel resultieren, dar! 1, 2, 3 1, 3, 2 2, 1, 3 1 1 2 3 2 3 1 2 2, 3, 1 3, 1, 2 3, 2, 1 2 3 3 1 3 2 1 1 Es gibt also: Sechs unterschiedliche Eingabefolgen und somit 6 unterschiedliche Bäume. Allgemein können n Elemente zu n! verschiedenen Anordnungen zusammengestellt werden. Suchaufwand N +1 ⋅ ld ( N + 1) − 1 N Zur Bestimmung des Suchaufwands stellt man sich vor, daß ein Baum aus dem leeren Baum durch sukzessives Einfuegen der N Schlüssel entstanden ist. Daraus resultieren N! Permutationen der N Schlüssel. Über all diese Baumstrukturen ist der Mittelwert zu bilden, um schließlich den Suchaufwand festlegen zu können. Aus den Schlüsselwerten 1, 2, ... , N interessiert zunächst das Element k, das die Wurzel bildet. Der mittlere Suchaufwand für einen vollen Baum beträgt Z mit = 205 Algorithmen und Datenstrukturen k Hier gibt es: (k-1)! Unterbäume Schlüsseln 1..N Hier gibt es: (N-k)! Unterbäume mit den Schlüsseln k+1, ... , N Der mittlere Suchaufwand im gesamten Baum ist: ZN = 1 ( N + Z k −1 ⋅ ( k − 1) + Z N − k ⋅ ( N − k )) N Zk-1: mittlerer Suchaufwand im linken Unterbaum ZN-k: mittlerer Suchaufwand im rechten Unterbaum Zusätzlich zu diesen Aufwendungen entsteht ein Aufwand für das Einfügen der beiden Teilbäume an die Wurzel. Das geschieht (N-1)-mal. Zusammen mit dem dem Suchschritt selbst ergibt das N-mal. Der angegebene Suchaufwand gilt nur für die Wurzel mit dem Schlüssel k. Da alle Werte für k gleichwahrscheinlich sind, gilt allgemein: ZN (k) = 2 N 1 N ⋅ ( N + Z ⋅ ( k − ) + Z ⋅ ( N − k )) Z = 1 + ⋅ ∑ (Z k −1 ⋅ ( k − 1) 1 bzw. ∑ N k −1 N−k N 2 k =1 N 2 k =1 N −1 2 ⋅ ∑ (Z k −1 ⋅ ( k − 1) ( N − 1) 2 k =1 N −1 2 N 2 = 2 ⋅ ∑ Z k −1 ⋅ ( k − 1) − ⋅ ∑ Z k −1 ⋅ ( k − 1) N k =1 ( N − 1) 2 k −1 bzw. für N - 1: Z N −1 = 1 + Z N − Z N −1 Es läßt sich daraus ableiten: Mit der YN = YN −1 Ersatzfunktion 2⋅N −1 N N −1 ⋅ Z N +1 + ⋅ ZN = N +1 N N ⋅ ( N + 1) YN = N ⋅ ZN N +1 132 die Rekursionsformel: N N N 2⋅N −1 2⋅i −1 1 132 + bzw. nach Auflösung YN = ∑ = 2 ⋅ ∑ − 3⋅ N ⋅ ( N + 1) N +1 i =1 i ⋅ ( i + 1) i =1 i Einsetzen ergibt: ZN = 2 ⋅ folgt N +1 N +1 ⋅ HS N − 3 = 2 ⋅ ⋅ ( HS N +1 − 1) − 1 N N vgl. Wettstein, H.: Systemprogrammierung, 2. Auflage, S.291 206 Algorithmen und Datenstrukturen N "HS" ist die harmonische Summe: HS N = ∑ i =1 1 N Sie läßt sich näherungsweise mit ln( N ) + 0.577 ⋅ (ln( N )) = 0.693 ⋅ ld ( N ) . Damit ergibt . ⋅ ld ( N + 1) − 2 sich schließlich: Z mit = 14 Darstellung Jeder geordnete binäre Baum ist eindeutig durch folgende Angaben bestimmt: 1. Angabe der Wurzel 2. Für jede Kante Angabe des linken Teilbaums ( falls vorhanden) sowie des rechten Teilbaums (falls vorhanden) Die Angabe für die Verzweigungen befinden sich in den Baumknoten, die die zentrale Konstruktionseinheit für den Aufbau binärerer Bäume sind. 207 Algorithmen und Datenstrukturen 4.2.2 Operationen 1. Generieren eines Suchbaums Bsp.: Gestalt eines binären Suchbaums nach der Eingabe der Schlüsselfolge (12, 7, 15, 5, 8, 13, 2, 6, 14). Schlüssel 12 LINKS RECHTS 7 5 2 15 8 13 6 14 Abb.: Baumknotendarstellung und Test eines binären Suchbaumknotens in Java 133 // Elementarer Knoten eines binaeren Baums, der nicht ausgeglichen ist // Der Zugriff auf diese Klasse ist nur innerhalb eines Verzeichnisses // bzw. Pakets moeglich class BinaerBaumknoten<T extends Comparable> { // Instanzvariable protected BinaerBaumknoten<T> links; protected BinaerBaumknoten<T> rechts; public T daten; // Konstruktor public BinaerBaumknoten(T datenElement) { this(datenElement, null, null ); } public BinaerBaumknoten(T datenElement, BinaerBaumknoten<T> l, BinaerBaumknoten<T> r) { daten = datenElement; links = l; 133 pr12362 208 // linker Teilbaum // rechter Teilbaum // Dateninhalt der Knoten Algorithmen und Datenstrukturen rechts = r; } public void insert (T x) { if (x.compareTo(daten) > 0) // dann rechts { if (rechts == null) rechts = new BinaerBaumknoten<T>(x); else rechts.insert(x); } else // sonst links { if (links == null) links = new BinaerBaumknoten<T> (x); else links.insert(x); } } public BinaerBaumknoten<T> getLinks() { return links; } public BinaerBaumknoten<T> getRechts() { return rechts; } } public class TestGenericBinaerBaumKnoten { public static void main (String args[]) { BinaerBaumknoten<Integer> baum = null; /* for (int i = 0; i < 20; i++) // 20 Zusfallsstrings speichern { String s = "Zufallszahl " + (int)(Math.random() * 100); if (baum == null) baum = new BinaerBaumknoten(s); } print(baum); // Sortiert wieder ausdrucken */ for (int i = 0; i < 10; i++) { // Erzeuge eine Zahl zwischen 0 und 100 Integer r = new Integer((int)(Math.random()*100)); if (baum == null) baum = new BinaerBaumknoten<Integer>(r); else baum.insert(r); } System.out.println("Inorder-Durchlauf"); print(baum); System.out.println(); System.out.println("Baumdarstellung um 90 Grad versetzt"); ausgBinaerBaum(baum,0); System.out.print("Kleinster Wert: "); // System.out.print(((Integer)(findeMin(baum))).intValue()); System.out.print(findeMin(baum)); System.out.println(); System.out.print("Groesster Wert: "); // System.out.print(((Integer)(findeMax(baum))).intValue()); System.out.print(findeMax(baum)); System.out.println(); } public static <T extends Comparable> void print (BinaerBaumknoten<? extends T> baum) // Rekursive Druckfunktion { if (baum == null) return; print(baum.getLinks()); System.out.print(baum.daten + " "); print(baum.getRechts()); } public static <T extends Comparable> void ausgBinaerBaum(BinaerBaumknoten<T> b, int stufe) { if (b != null) { ausgBinaerBaum(b.getRechts(), stufe + 1); for (int i = 0; i < stufe; i++) 209 Algorithmen und Datenstrukturen { System.out.print(" "); } System.out.println(b.daten); ausgBinaerBaum(b.getLinks(), stufe + 1); } } public static <T extends Comparable> T findeMin(BinaerBaumknoten<T> b) { return datenZugriff( findMin(b) ); } public static <T extends Comparable> T findeMax(BinaerBaumknoten<T> b) { return datenZugriff( findMax(b) ); } public static <T extends Comparable> T datenZugriff(BinaerBaumknoten<T> b) { return b == null ? null : b.daten; } public static <T extends Comparable> BinaerBaumknoten<T> findMin(BinaerBaumknoten<T> b) { if (b == null) return null; else if (b.getLinks() == null) return b; return findMin(b.getLinks()); } public static <T extends Comparable> BinaerBaumknoten<T> findMax(BinaerBaumknoten<T> b) { if (b != null) while (b.getRechts() != null) b = b.getRechts(); return b; } } Abb.: Ergebnisdarstellung Der Inorder-Durchlauf des binären Suchbaums (LWR-Ordnung 134) durchläuft die Schlüsselwerte monoton aufsteigend. 134 vgl. 4.2.3 210 Algorithmen und Datenstrukturen 2. Suchen und Einfügen Vorstellung zur Lösung 1. Suche nach dem Schlüsselwert 2. Falls vorhanden kein Einfügen 3. Bei erfolgloser Suche Einfügen als Sohn des erreichten Blatts Eine generische Klasse für den binären Suchbaum in Java 135 Der binäre Suchbaum setzt voraus, dass alle Datenelemente in eine Ordnungsbeziehung 136 gebracht werden können. Eine generische Klasse für einen binären Suchbaum erfordert daher ein Interface, das Ordnungsbeziehungen zwischen Daten eines Datenbestands festlegt. Diese Eigenschaft besitzt das Interface Comparable: public interface Comparable { int compareTo(Comparable rs) } Das Interface 137 zeigt, dass zwei Datenelemente über die Methode „compareTo“ verglichen werden können. Über die Defintion eines Interface wird auch der zugehörige Referenztyp erzeugt, der wie andere Datentypen eingesetzt werden kann. // Freier binaerer Intervallbaum // Generische Klasse fuer einen unausgeglichenen binaeren Suchbaum // // Konstruktor: Initialisierung der Wurzel mit dem Wert null // // **********oeffentlich zugaengliche Methoden************************************* // void insert( x ) -> Fuege x ein // void remove( x ) -> Entferne x // Comparable find( x ) -> Gib das Element zurueck, das zu x passt // Comparable findMin( ) -> Rueckgabe des kleinsten Elements // Comparable findMax( ) -> Rueckgabe des groessten Elements // boolean isEmpty( ) -> Return true if empty; else false // void makeEmpty( ) -> Entferne alles // void printTree( ) -> Ausgabe der Binaerbaum-Elemente in sort. Folge // void ausgBinaerBaum() -> Ausgabe: Binaerbaum-Elemente um 90 Grad vers. /* * Implementiert einen unausgeglichenen binaeren Suchbaum. * Das Einordnen in den Suchbaum basiert auf der Methode compareTo */ public class BinaererSuchbaum<T extends Comparable> { // Private Datenelemente /* Die Wurzel des Baums */ 135 vgl. pr42110 vgl. Kapitel 1, 1.2.2.2 137 Java-Interfaces werden in der Regel als eine Form abstrakter Klassen beschrieben, durch die einzelne Klassen der Hierarchie zusätzliche Funktionalität erhalten können. Sollen die Klassen diese Funktionalität durch Vererbung erhalten, müssten sie in einer gemeinsamen Superklasse angesiedelt werden. Weil ein Interface keine Implementierung enthält, kann auch keine Instanz davon erzeugt werden. Eine Klasse, die nicht alle Methoden eines Interface implementiert, wird zu einer abstrakten Klasse. 136 211 Algorithmen und Datenstrukturen private BinaerBaumknoten<T> root; // Oeffentlich zugaengliche Methoden /* * Konstruktor. */ public BinaererSuchbaum() { root = null; } /* * Einfuegen eines Elements in den binaeren Suchbaum * Duplikate werden ignoriert */ public void insert( T x ) { root = insert(x, root); } /* * Entfernen aus dem Baum. Falls x nicht da ist, geschieht nichts */ public void remove( T x ) { root = remove(x, root); } /* * finde das kleinste Element im Baum */ public T findMin() { return elementAt(findMin(root)); } /* * finde das groesste Element im Baum */ public T findMax() { return elementAt(findMax(root)); } /* * finde ein Datenelement im Baum */ public T find(T x) { return elementAt(find(x, root)); } /* * Mache den Baum leer */ public void makeEmpty() { root = null; } /* * Test, ob der Baum leer ist */ public boolean isEmpty() { return root == null; } /* * Ausgabe der Datenelemente in sortierter Reihenfolge */ public void printTree() { if( isEmpty( ) ) System.out.println( "Baum ist leer" ); else printTree( root ); } /* * Ausgabe der Elemente des binaeren Baums um 90 Grad versetzt */ public void ausgBinaerBaum() { if( isEmpty() ) System.out.println( "Leerer baum" ); else ausgBinaerBaum( root,0 ); } // Private Methoden /* * Methode fuer den Zugriff auf ein Datenelement */ 212 Algorithmen und Datenstrukturen private T elementAt( BinaerBaumknoten<T> b ) { return b == null ? null : b.daten; } /* * Interne Methode fuer das Einfuegen in einen Teilbaum */ private BinaerBaumknoten<T> insert(T x, BinaerBaumknoten<T> b) { /* 1*/ if( b == null ) /* 2*/ b = new BinaerBaumknoten<T>( x, null, null ); /* 3*/ else if( x.compareTo( b.daten ) < 0 ) /* 4*/ b.links = insert( x, b.links ); /* 5*/ else if( x.compareTo( b.daten ) > 0 ) /* 6*/ b.rechts = insert( x, b.rechts ); /* 7*/ else /* 8*/ ; // Duplikat; tue nichts /* 9*/ return b; } /* * Interne Methode fuer das Entfernen eines Knoten in einem Teilbaum */ private BinaerBaumknoten<T> remove(T x, BinaerBaumknoten<T> b) { if( b == null ) return b; // nichts gefunden; tue nichts if( x.compareTo(b.daten) < 0 ) b.links = remove(x, b.links ); else if( x.compareTo(b.daten) > 0 ) b.rechts = remove( x, b.rechts ); else if( b.links != null && b.rechts != null ) // Zwei Kinder { b.daten = findMin(b.rechts).daten; b.rechts = remove(b.daten, b.rechts); } else b = ( b.links != null ) ? b.links : b.rechts; return b; } /* * Interne Methode zum Bestimmen des kleinsten Datenelements im Teilbaum */ private BinaerBaumknoten<T> findMin(BinaerBaumknoten<T> b) { if (b == null) return null; else if( b.links == null) return b; return findMin(b.links ); } /* * Interne Methode zum Bestimmen des groessten Datenelements im Teilbaum */ private BinaerBaumknoten<T> findMax( BinaerBaumknoten<T> b) { if( b != null ) while( b.rechts != null ) b = b.rechts; return b; } /* * Interne Methode zum Bestimmen eines Datenelements im Teilbaum. */ private BinaerBaumknoten<T> find(T x, BinaerBaumknoten<T> b) { if(b == null) 213 Algorithmen und Datenstrukturen return null; if( x.compareTo(b.daten ) < 0) return find(x, b.links); else if( x.compareTo(b.daten) > 0) return find(x, b.rechts); else return b; // Gefunden! } /* * Interne Methode zur Ausgabe eines Teilbaums in sortierter Reihenfolge */ private void printTree(BinaerBaumknoten<T> b) { if(b != null) { printTree(b.links); System.out.print(b.daten); System.out.print(' '); printTree( b.rechts ); } } /* * Ausgabe des Binaerbaums um 90 Grad versetzt */ private void ausgBinaerBaum(BinaerBaumknoten<T> b, int stufe) { if (b != null) { ausgBinaerBaum(b.links, stufe + 1); for (int i = 0; i < stufe; i++) { System.out.print(' '); } System.out.println(b.daten); ausgBinaerBaum(b.rechts, stufe + 1); } } 214 Algorithmen und Datenstrukturen Löschen eines Knoten Es soll ein Knoten mit einem bestimmten Schlüsselwert entfernt werden. Fälle A) Der zu löschende Knoten ist ein Blatt Bsp.: vorher nachher Abb.: Das Entfernen kann leicht durchgeführt werden B) Der zu löschende Knoten hat genau einen Sohn nachher vorher Abb.: C) Der zu löschende Knoten hat zwei Söhne 215 Algorithmen und Datenstrukturen nachher vorher Abb.: Der Knoten k wird durch den linken Sohn ersetzt. Der rechte Sohn von k wird rechter Sohn der rechtesten Ecke des linken Teilbaums. Der resultierende Teilbaum T' ist ein Suchbaum, häufig allerdings mit erheblich vergrößerter Höhe. Aufgaben: 1. Gegeben ist ein binärer Baum folgender Gestalt: k k1 k2 k3 Die Wurzel wird gelöscht. Welche Gestalt nimmt der Baum dann an: k1 k3 k2 Abb.: Es ergibt sich eine Höhendifferenz ∂H , die durch folgende Beziehung eingegrenzt ist: −1 ≤ ∂H ≤ H (TL ) 216 Algorithmen und Datenstrukturen H (TL ) ist die Höhe des linken Teilbaums. 2. Gegeben ist die folgende Gestalt eines binären Baums 12 7 15 5 13 2 6 14 Welche Gestalt nimmt dieser Baum nach dem Entfernen der Schlüssel mit den unter a) bis f) angegebenen Werten an? a) 2 b) 6 12 7 15 5 13 14 c) 13 12 7 15 5 14 d) 15 12 7 14 5 e) 5 12 7 14 217 Algorithmen und Datenstrukturen f) 12 7 14 Schlüsseltransfer Der angegebene Algorithmus zum Löschen von Knoten kann zu einer beträchtlichen Vergrößerung der Baumhöhe führen. Das bedeutet auch eine beträchtliche Steigerung des mittleren Suchaufwands. Man ersetzt häufig die angegebene Verfahrensweise durch ein anderes Verfahren, das unter dem Namen Schlüsseltransfer bekannt ist. Der zu löschende Schlüssel (Knoten) wird ersetzt durch den kleinsten Schlüssel des rechten oder den größten Schlüssel des linken Teilbaums. Dieser ist dann nach Fall A) bzw. B) aus dem Baum herauszunehmen. Bsp.: Abb.: Test der Verfahrensweise "Schlüsseltransfer": 1) Der zu löschende Baumknoten besteht nur aus einem Wurzelknoten, z.B.: Schlüssel LINKS 12 RECHTS Ergebnis: Der Wurzelknoten wird gelöscht. 2) Vorgegeben ist 218 Algorithmen und Datenstrukturen Schlüssel LINKS 12 RECHTS 7 5 8 Abb.: Der Wurzelknoten wird gelöscht. Ergebnis: 7 5 8 Abb.: 3) Vorgegeben ist 219 Algorithmen und Datenstrukturen 12 Schlüssel LINKS RECHTS 7 5 15 8 13 14 Abb.: Der Wurzelknoten wird gelöscht. Ergebnis: Schlüssel LINKS 13 RECHTS 7 5 15 8 14 Abb.: Implementierung der Verfahrenweise Schlüsseltransfer Baumknoten in einem binären Suchbaum in Java 138 zum Löschen von /* * Interne Methode fuer das Entfernen eines Knoten in einem Teilbaum 138 pr42000 220 Algorithmen und Datenstrukturen */ private BinaerBaumknoten<T> remove(T x, BinaerBaumknoten<T> b) { if( b == null ) return b; // nichts gefunden; tue nichts if( x.compareTo(b.daten) < 0 ) b.links = remove(x, b.links ); else if( x.compareTo(b.daten) > 0 ) b.rechts = remove( x, b.rechts ); else if( b.links != null && b.rechts != null ) // Zwei Kinder { b.daten = findMin(b.rechts).daten; b.rechts = remove(b.daten, b.rechts); } else b = ( b.links != null ) ? b.links : b.rechts; return b; } 221 Algorithmen und Datenstrukturen 4.2.3 Ordnungen und Durchlaufprinzipien Das Prinzip, wie ein geordneter Baum durchlaufen wird, legt eine Ordnung auf der Menge der Knoten fest. Es gibt 3 Möglichkeiten (Prinzipien), die Knoten eines binären Baums zu durchlaufen: 1. Inordnungen LWR-Ordnung (1) Durchlaufen (Aufsuchen) des linken Teilbaums in INORDER (2) Aufsuchen der BAUMWURZEL (3) Durchlaufen (Aufsuchen) des rechten Teilbaums in INORDER RWL-Ordnung (1) Durchlaufen (Aufsuchen) des rechten Teilbaums in INORDER (2) Aufsuchen der BAUMWURZEL (3) Durchlaufen (Aufsuchen) des Teilbaums in INORDER Der LWR-Ordnung und die RWL-Ordnung sind zueinander invers. Die LWR Ordnung heißt auch symmetrische Ordnung. 2. Präordnungen WLR-Ordnung (1) Aufsuchen der BAUMWURZEL (2) Durchlaufen (Aufsuchen) des linken Teilbaums in PREORDER (3) Durchlaufen (Aufsuchen) des rechten Teilbaums in PREORDER WRL-Ordnung (1) Aufsuchen der BAUMWURZEL (2) Durchlaufen (Aufsuchen) des rechten Teilbaums in PREORDER (3) Durchlaufen (Aufsuchen) des linken Teilbaums in PREORDER Es wird hier grundsätzlich die Wurzel vor den (beiden) Teilbäumen durchlaufen. 3. Postordnungen LRW-Ordnung (1) Durchlaufen (Aufsuchen) des linken Teilbaums in POSTORDER (2) Durchlaufen (Aufsuchen) des rechten Teilbaums in POSTORDER (3) Aufsuchen der BAUMWURZEL Zunächst werden die beiden Teilbäume und dann die Wurzel durchlaufen. RLW-Ordnung (1) Durchlaufen (Aufsuchen) des rechten Teilbaums in POSTORDER (2) Durchlaufen (Aufsuchen) des linken Teilbaums in POSTORDER (3) Aufsuchen der BAUMWURZEL Zunächst werden die beiden Teilbäume und dann die Wurzel durchlaufen. 222 Algorithmen und Datenstrukturen Traversierungen eines eines binären (Struktur-) Baums mit Operanden in den Blättern und Operatoren in den inneren Knoten import java.util.*; class Baumknoten<T> { private T daten; private Baumknoten<T> links, rechts; public Baumknoten(T daten) { this(daten,null,null); } public Baumknoten(T daten, Baumknoten<T> links, Baumknoten<T> rechts) { this.links = links; this.rechts = rechts; this.daten = daten; } public T getDaten() { return daten; } public Baumknoten<T> getLinks() { return links; } public Baumknoten<T> getRechts() { return rechts; } } public class GenBaumknoten { private static Baumknoten wurzel; private static void praeorderAusg(Baumknoten b) { // Rekursiver Durchlauf if (b == null) return; { System.out.print(b.getDaten() + " "); praeorderAusg(b.getLinks()); praeorderAusg(b.getRechts()); } } private static void postorderAusg(Baumknoten b) { // Rekursiver Durchlauf if (b == null) return; { postorderAusg(b.getLinks()); postorderAusg(b.getRechts()); System.out.print(b.getDaten() + " "); } } private static void inorderAusg(Baumknoten b) { // Rekursiver Durchlauf if (b == null) return; { inorderAusg(b.getLinks()); System.out.print(b.getDaten() + " "); 223 Algorithmen und Datenstrukturen inorderAusg(b.getRechts()); } } public static void main(String { Baumknoten<Character> h = new Baumknoten<Character> i = new Baumknoten<Character> d = new Baumknoten<Character> e = new Baumknoten<Character> b = new Baumknoten<Character> f = new Baumknoten<Character> g = new Baumknoten<Character> c = new Baumknoten<Character> a = new wurzel = a; // Rekursive Durchlaeufe praeorderAusg(wurzel); System.out.println(); inorderAusg(wurzel); System.out.println(); postorderAusg(wurzel); System.out.println(); } } args[]) Baumknoten<Character>('C'); Baumknoten<Character>('D'); Baumknoten<Character>('A'); Baumknoten<Character>('B'); Baumknoten<Character>('*',d,e); Baumknoten<Character>('*',h,i); Baumknoten<Character>('E'); Baumknoten<Character>('+',f,g); Baumknoten<Character>('+',b,c); Es wird ein binärer Baum folgender Gestalt erzeugt: 224 Algorithmen und Datenstrukturen ’+’ ‘*’ ’A’ ‘+’ ’B’ ’*’ ’C’ Abb.: Gestalt des Strukturbaums Der vorliegende Baum enthält folgende Traversierungen: Abb.: Traversierungen 225 ’E’ ’E’ Algorithmen und Datenstrukturen Aufgaben: Gegeben sind eine Reihe binärer Bäume. Welche Folgen entstehen beim Durchlaufen der Knoten nach den Prinzipien "Inorder (LWR)", "Praeorder WLR" und "Postorder (LRW)". 1. A B C E D F I G H J K L "Praeorder": A B C E I F J D G H K L "Inorder": EICFJBGDKHLA "Postorder": I E J F C G K L H D B A 2. + * A + B * C E D "Praeorder": + * A B + * C D E "Inorder": A*B+C*D+E "Postorder": A B * C D * E + + Diese Aufgabe zeigt einen Strukturbaum (Darstellung der hierarchischen Struktur eines arithmetischen Ausdrucks). Diese Baumdarstellung ist besonders günstig für die Übersetzung eines Ausdrucks in Maschinensprache. Aus der vorliegenden Struktur lassen sich leicht die unterschiedlichen Schreibweisen eines arithmetischen Ausdrucks herleiten. So liefert das Durchwandern des Baums in "Postorder" die Postfixnotation, in "Praeorder" die Praefixnotation". 3. + A * B C "Praeorder": + A * B C "Inorder": A+B*C "Postorder": A B C * + 226 Algorithmen und Datenstrukturen 4. * + A C B "Praeorder": * + A B C "Inorder": A+B*C "Postorder": A B + C * Anwendungen der Durchlaufprinzipien Mit Hilfe der angegebenen Ordnungen bzw. Durchlaufprinzipien lassen sich weitere Operationen auf geordneten Wurzelbäumen bestimmen, z.B. „Grafische Darstellung eines binaeren Suchbaums 139“ private void zeichneBaum(BinaerBaumknoten b, int x, int y, int m, int s) { Graphics g = meinCanvas.getGraphics(); if (b != null) { if (b.links != null) { g.drawLine(x,y,x - m / 2,y + s); zeichneBaum(b.links,x - m / 2,y + s,m / 2,s); } if (b.rechts != null) { g.drawLine(x,y,x + m / 2,y+s); zeichneBaum(b.rechts,x + m / 2,y + s,m / 2,s); } } } } 139 vgl. pr42110 227 Algorithmen und Datenstrukturen 4.3 Balancierte Bäume Hier geht es darum, entartete Bäume (schiefe Bäume, Äste werden zu linearen Listen, etc.) zu vermeiden. Statische Optimierung heißt: Der ganze Baum wird neu (bzw. wieder neu) aufgebaut. Bei der dynamischen Optimierung wird der Baum während des Betriebs (bei jedem Ein- und Ausfügen) optimiert. Perfekt ausgeglichener, binärer Suchbaum Ein binärer Suchbaum sollte immer ausgeglichen sein. Der folgende Baum 1 2 3 4 5 ist zu einer linearen Liste degeneriert und läßt sich daher auch nicht viel schneller als eine lineare Liste durchsuchen. Ein derartiger binärer Suchbaum entsteht zwangsläufig, wenn die bei der Eingabe angegebene Schlüsselfolge in aufsteigend sortierter Reihenfolge vorliegt. Der vorliegende binäre Suchbaum ist selbstverständlich nicht ausgeglichen. Es gibt allerdings auch Unterschiede bei der Beurteilung der Ausgeglichenheit, z.B.: Die vorliegenden Bäume sind beide ausgeglichen. Der linke Baum ist perfekt ausbalanciert. Jeder Binärbaum ist perfekt ausbalanciert, falls jeder Knoten über einen linken und rechten Teilbaum verfügt, dessen Knotenzahl sich höchstens um den Wert 1 unterscheidet. Der rechte Teilbaum ist ein in der Höhe ausgeglichener (AVL 140-)Baum. Die Höhe der Knoten zusammengehöriger linker und rechter Teilbäume unterscheiden sich höchstens um den Wert 1. Jeder perfekt ausgeglichene Baum ist gleichzeitig auch ein in der Höhe ausgeglichener Binärbaum. Der umgekehrte Fall trifft allerdings nicht zu. Es gibt einen einfachen Algorithmus zum Erstellen eines pefekt ausgeglichenen Binärbaums 141, falls 140 141 nach den Anfangsbuchstaben der Namen seiner Entdecker: Adelson, Velskii u. Landes pr43205 228 Algorithmen und Datenstrukturen (1) die einzulesenden Schlüsselwerte sortiert in aufsteigender Reihenfolge angegeben werden (2) bekannt ist, wieviel Objekte (Schlüssel) werden müssen. import java.io.*; class PBBknoten { // Instanzvariable protected PBBknoten links; // linker Teilbaum protected PBBknoten rechts; // rechter Teilbaum public int daten; // Dateninhalt der Knoten // Konstruktoren public PBBknoten() { this(0,null,null); } public PBBknoten(int datenElement) { this(datenElement, null, null ); } public PBBknoten(int datenElement, PBBknoten l, PBBknoten r) { daten = datenElement; links = l; rechts = r; } public PBBknoten getLinks() { return links; } public PBBknoten getRechts() { return rechts; } } public class PBB { static BufferedReader ein = new BufferedReader(new InputStreamReader( System.in)); // Instanzvariable PBBknoten wurzel; // Konstruktor public PBB(int n) throws IOException { if (n == 0) wurzel = null; else { int nLinks = (n - 1) / 2; int nRechts = n - nLinks - 1; wurzel = new PBBknoten(); wurzel.links = new PBB(nLinks).wurzel; wurzel.daten = Integer.parseInt(ein.readLine()); wurzel.rechts = new PBB(nRechts).wurzel; } } public void ausgPBB() { ausg(wurzel,0); } private void ausg(PBBknoten b, int nSpace) 229 Algorithmen und Datenstrukturen { if (b != null) { ausg(b.rechts,nSpace += 6); for (int i = 0; i < nSpace; i++) System.out.print(" "); System.out.println(b.daten); ausg(b.links, nSpace); } } // Test public static void main(String args[]) throws IOException { int n; System.out.print("Gib eine ganze Zahl n an, "); System.out.print("gefolgt von n ganzen Zahlen in "); System.out.println("aufsteigender Folge"); n = Integer.parseInt(ein.readLine()); PBB b = new PBB(n); System.out.print( "Hier ist das Resultat: ein perfekt balancierter Baum, "); System.out.println("die Darstellung erfogt um 90 Grad versetzt"); b.ausgPBB(); } } Schreibtischtest: Wird mit n = 10 aufgerufen, dann wird anschließend die Anzahl der Knoten berechnet, die sowohl in den linken als auch in den rechten Teilbaum eingefügt werden. Da der Wurzelknoten keinem Teilbaum zugeordnet werden kann, ergeben sich für die beiden Teilbäume (10 – 1) Knoten. Das ergibt nLinks = 4, nRechts = 5. Anschließend wird der Wurzelknoten erzeugt. Es folgt der rekursive Aufruf wurzel.links = new PBB(nLinks).wurzel; mit nLinks = 4. Die Folge davon ist: Einlesen von 4 Zahlen und Ablage dieser Zahlen im linken Teilbaum. Die danach folgende Zahl wird im Wurzelknoten abgelegt. Der rekursive Aufruf wurzel.rechts = new PBB(nRechts).wurzel; mit nRechts = 5 verarbeitet die restlichen 5 Zahlen und erstellt damit den rechten Teilbaum. Durch jeden rekursiven Aufruf wird ein Baum mit zwei ungefähr gleich großen Teilbäumen erzeugt. Da die im Wurzelknoten enthaltene Zahl direkt nach dem erstellen des linken Teilbaum gelesen wird, ergibt sich bei aufsteigender Reihenfolge der Eingabedaten ein binärer Suchbaum, der außerdem noch perfekt balanciert ist. 230 Algorithmen und Datenstrukturen 4.3.1 Statisch optimierte Bäume Der Algorithmus zum Erstellen eines perfekt ausgeglichenen Baums kann zur statischen Optimierung binärer Suchbäume verwendet werden. Das Erstellen des binären Suchbaums erfolgt dabei nach der bekannten Verfahrensweise. Wird ein solcher Baum in Inorder-Folge durchlaufen, so werden die Informationen in den Baumknoten aufsteigend sortiert. Diese sortierte Folge ist Eingangsgröße für die statische Optimierung. Es wird mit der sortiert vorliegende Folge der Schlüssel ein perfekt ausgeglichener Baum erstellt. Bsp.: Ein Java-Applet zur Demonstration der statischen Optimierung. 142 Zufallszahlen werden generiert und in einen freien binären Intervallbaum aufgenommen, der im oberen Bereich des Fensters gezeigt werden. Über Sortieren erfolgt ein Inorder-Durchlauf des binären Suchbaums, über „Perfekter BinaerBaum“ Erzeugen und Darstellen des perfekt ausgeglichen binären Suchbaums. Abb.: 142 vgl. pr43205, ZPBBApplet.java und ZPBBApplet.html 231 Algorithmen und Datenstrukturen 4.3.2 AVL-Baum Der wohl bekannteste dynamisch ausgeglichene Binärbaum ist der AVL-Baum, genannt nach dem Anfangsbuchstaben seiner Entdecker (Adelson, Velskii und Landis). Ein Baum hat die AVL-Eigenschaft, wenn in jedem Knoten sich die Höhen der beiden Unterbäume höchstens um 1 (|HR - HL| <= 1) unterscheiden. Die Last ("Balance") muß in einem Knoten mitgespeichert sein. Es genügt aber als Maß für die Unsymmetrie die Höhendifferenz ∂H festzuhalten, die nur die Werte -1 (linkslastig), 0 (gleichlastig) und +1 (rechtslastig) annehmen kann. 1. Einfügen Beim Einfügen eines Knoten können sich die Lastverhältnisse nur auf dem Wege, den der Suchvorgang in Anspruch nimmt, ändern. Der tatsächliche Ort der Änderung ist aber zunächst unbekannt. Der Knoten ist deshalb einzufügen und auf notwendige Berichtigungen zu überprüfen. Bsp.: Gegeben ist der folgende binäre Baum 8 4 2 10 6 Abb.: 1) In diesen Baum sind die Knoten mit den Schlüsseln 9 und 11 einzufügen. Die Gestalt des Baums ist danach: 8 4 2 10 6 9 Abb.: Die Schlüsel 9 und 11 können ohne zusätzliches Ausgleichen eingefügt werden. 232 11 Algorithmen und Datenstrukturen 2) In den gegebenen Binärbaum sind die Knoten mit den Schlüsseln 1, 3, 5 und 7 einzufügen. Wie ist die daraus resultierende Gestalt des Baums beschaffen? 8 4 2 -1 -2 10 6 1 Abb.: Schon nach dem Einfügen des Schlüsselwerts „1“ ist anschließendes Ausgleichen unbedingt erforderlich. 3) Wie könnte das Ausgleichen vollzogen werden? Eine Lösungsmöglichkeit ist hier bspw. eine einfache bzw. eine doppelte Rotation. 4 2 8 1 6 10 Abb.: Gestalt des Baums nach „Rotation“ b) Beschreibe den Ausgleichsvorgang, nachdem die Schlüssel 3, 5 und 7 eingefügt wurden! 4 2 1 8 3 6 5 10 7 Abb.: Das Einfügen der Schlüssel mit den Werten „3“, „5“ und „7“ verletzt die AVL-Eigenschaft nicht Nachdem ein Knoten eingefügt ist, ist der Pfad, den der Suchvorgang für das Einfügen durchlaufen hat, aufwärts auf notwendige Berichtigungen zu überprüfen. Bei dieser Prüfung wird die Höhendifferenz des linken und rechten Teilbaums bestimmt. Es können generell folgende Fälle eintreten: 233 Algorithmen und Datenstrukturen (1) ∂H = +1 bzw. -1 Eine Verlängerung des Baums auf der Unterlastseite gleicht die Last aus, die Verlängerung wirkt sich nicht weiter nach oben aus. Die Prüfung kann abgebrochen werden. (2) ∂H = 0 Das bedeutet: Verlängerung eines Teilbaums Hier ist der Knoten dann ungleichlastig ( ∂H = +1 bzw. -1), die AVL-Eigenschaft bleibt jedoch insgesamt erhalten. Der Baum wurde länger. (3) ∂H = +1 bzw. -1 Das bedeutet: Verlängerung des Baums auf der Überlastseite. Die AVL-Eigenschaft ist verletzt, wenn ∂H = +2 bzw. -2. Sie wird durch Rotationen berichtigt. Die Information über die Ausgeglichenheit steht im AVL-Baumknoten, z.B.: struct knoten { int num, // Schluessel bal; // Ausgleichsfaktor struct knoten *zLinks, *zRechts; }; Abb.: AVL-Baumknoten mit Ausgleichfaktor in C++ In der Regel gibt es folgende Faktoren für die "Ausgeglichenheit" je Knoten im AVLBaum: "-1": Höhe des linken Teilbaums ist um eine Einheit (ein Knoten) größer als die Höhe im rechten Teilbaum. "0": Die Höhen des linken und rechten Teilbaums sind gleich. "1": Die Höhe des linken Teilbaums ist um eine Einheit (ein Knoten) kleiner als die Höhe des rechten Teilbaums. Bsp.: Die folgende Darstellung zeigt den Binärbaum unmittelbar nach dem Einfügen eines Baumknoten. Daher kann hier der Faktor für Ausgeglichenheit -2 bis 2 betragen. 12 +1 7 17 +1 +2 5 0 9 14 -1 0 8 24 +2 25 0 +1 30 0 234 Algorithmen und Datenstrukturen Nach dem Algorithmus für das Einfügen ergibt sich folgender AVL-Baum: 12 0 7 17 +1 +1 5 9 14 25 -1 0 8 24 0 30 0 0 Es gibt 4 Möglichkeiten die Ausgeglichenheit, falls sie durch Einfügen eines Baumknoten gestört wurde, wieder herzustellen. A A B b a A a B c c 1a B b a b 1b A a B c 2a c b 2b Abb.: Die vier Ausgangssituationen bei der Wiederherstellung der AVL-Eigenschaft Von den 4 Fällen sind jeweils die Fälle 1a, 1b und die Fälle 2a, 2b zueinander symmetrisch. Für den Fall 1a kann durch einfache Rotation eine Ausgeglichenheit erreicht werden. B 0 b A 0 c a Im Fall 1b muß die Rotation nach links erfolgen. 235 Algorithmen und Datenstrukturen Für die Behandlung von Fall 2a der Abb. 1 wird der Teilbaum c aufgeschlüsselt in dessen Teilbäume c1 und c2: A -2 B a 2 b C -1 c1 c2 Abb.: Durch zwei einfache Rotationen kann der Baum ausgeglichen werden: 1. Rotation 2. Rotation A C -2 C 0 a B -2 B A +1 c2 b +1 c1 c2 a +1 b c1 Abb.: Die generische Klasse „AvlBaum“ in Java 143 Grundlagen: Die AVL-Eigenschaft ist verletzt, wenn diese Höhendifferenz +2 bzw. –2 ist. Der Knoten, der diesen Wert erhalten hat, ist der Knoten „alpha“, dessen Unausgeglichenheit auf einen der folgenden 4 Fälle zurückzuführen ist: 1. Einfügen in den linken Teilbaum, der vom linken Nachkommen des Knoten „alpha“ bestimmt ist. 2. Einfügen in den rechten Teilbaum, der vom linken Nachkommen des Knoten „alpha“ bestimmt ist. 3. Einfügen in den linken Teilbaum, der vom rechten Nachkommen des Knoten „alpha“ bestimmt ist. 4. Einfügen in den rechten Teilbaum, der vom rechten Nachkommen des Knoten „alpha“ bestimmt ist 143 pr43210 236 Algorithmen und Datenstrukturen Fall 1 und Fall 4 bzw. Fall 2 und Fall 3 sind Spiegelbilder, zeigen also das gleiche Verhalten. Fall 1 kann durch einfache Rotation behandelt werden und ist leicht zu bestimmen, daß das Einfügen „außerhalb“ (links – links bzw. rechts – rechts im Fall 4 stattfindet. Fall 2 kann durch doppelte Rotation behandelt werden und ist ebenfalls leicht zu bestimmen, da das Einfügen „innerhalb“ (links –rechts bzw. rechts – links) erfolgt. Die einfache Rotation: Die folgende Darstellung beschreibt den Fall 1 vor und nach der Rotation: k2 k1 k1 k2 Z Y X Y Z X Abb.: Die folgende Darstellung beschreibt Fall 4 vor und nach der Rotation: k1 k2 k2 k1 X Y X Y Z Z Abb.: Doppelrotation: Die einfache Rotation führt in den Fällen 2 und 3 nicht zum Erfolg. Fall 2 muß durch eine Doppelrotation (links – rechts) behandelt werden. k3 k2 k1 k1 k3 D k2 B A A B C Abb.: 237 C D Algorithmen und Datenstrukturen Auch Fall 3 muß durch Doppelrotation behandelt werden k1 k3 k2 A k1 k2 k3 D B C A B D C Abb.: Implementierung: Zum Einfügen eines Knoten mit dem Datenwert „x“ in einen AVLBaum, wird „x“ rekursiv in den betoffenen Teilbaum eingesetzt. Falls die Höhe dieses Teilbaums sich nicht verändert, ist das Einfügen beendet. Liegt Unausgeglichenheit vor, dann ist einfache oder doppelte Rotation (abhängig von „x“ und den Daten des betroffenen Teilbaums) nötig. Avl-Baumknoten 144 Er enthält für jeden Knoten eine Angabe zur Höhe(ndifferenz) seiner Teilbäume. // Baumknoten fuer AVL-Baeume class GenAvlKnoten<T extends Comparable> { // Instanzvariable protected GenAvlKnoten<T> links; // Linkes Kind protected GenAvlKnoten<T> rechts; // Rechtes Kind protected int hoehe; // Hoehe public T daten; // Das Datenelement // Konstruktoren public GenAvlKnoten(T datenElement) { this(datenElement, null, null ) } public GenAvlKnoten( T datenElement, GenAvlKnoten<T> lb, GenAvlKnoten<T> rb ) { daten = datenElement; links = lb; rechts = rb; hoehe = 0; } } Der Avl-Baum 145 Bei jedem Schritt ist festzustellen, ob die Höhe des Teilbaums, in dem ein Element eingefügt wurde, zugenommen hat. private static <T extends Comparable> int hoehe(GenAvlKnoten<T> b) { return b == null ? -1 : b.hoehe; } Die Methode „insert“ führt das Einfügen eines Baumknoten in den Avl-Baum aus: /* 144 145 vgl. pr43210 vgl. pr43210 238 Algorithmen und Datenstrukturen * Interne Methode zum Einfuegen eines Baumknoten in einen Teilbaum. * x ist das einzufuegende Datenelement. * b ist der jeweilige Wurzelknoten. * Rueckgabe der neuen Wurzel des jeweiligen Teilbaums. */ private GenAvlKnoten<T> insert(T x, GenAvlKnoten<T> b) { if( b == null ) b = new GenAvlKnoten<T>(x, null, null); else if (x.compareTo( b.daten) < 0 ) { b.links = insert(x, b.links ); if (hoehe( b.links ) - hoehe( b.rechts ) == 2 ) if (x.compareTo( b.links.daten ) < 0 ) b = rotationMitLinksNachf(b); else b = doppelrotationMitLinksNachf(b); } else if (x.compareTo( b.daten ) > 0 ) { b.rechts = insert(x, b.rechts); if( hoehe(b.rechts) - hoehe(b.links) == 2) if( x.compareTo(b.rechts.daten) > 0 ) b = rotationMitRechtsNachf(b); else b = doppelrotationMitRechtsNachf( b ); } else ; // Duplikat; tue nichts b.hoehe = max( hoehe( b.links ), hoehe( b.rechts ) ) + 1; return b; } Rotationen /* * Rotation Binaerbaumknoten mit linkem Nachfolger. * Fuer AVL-Baeume ist dies eine einfache Rotation (Fall 1). * Aktualisiert Angaben zur Hoehe, dann Rueckgabe der neuen Wurzel. */ private static <T extends Comparable> GenAvlKnoten<T> rotationMitLinksNachf(GenAvlKnoten<T> k2) { GenAvlKnoten<T> k1 = k2.links; k2.links = k1.rechts; k1.rechts = k2; k2.hoehe = max( hoehe( k2.links ), hoehe( k2.rechts ) ) + 1; k1.hoehe = max( hoehe( k1.links ), k2.hoehe ) + 1; return k1; } /* * Rotation Binaerbaumknoten mit rechtem Nachfolger. * Fuer AVL-Baeume ist dies eine einfache Rotation (Fall 4). * Aktualisiert Angaben zur Hoehe,, danach Rueckgabe der neuen Wurzel. */ private static <T extends Comparable> GenAvlKnoten<T> rotationMitRechtsNachf(GenAvlKnoten<T> k1) { GenAvlKnoten<T> k2 = k1.rechts; k1.rechts = k2.links; k2.links = k1; k1.hoehe = max( hoehe( k1.links ), hoehe( k1.rechts ) ) + 1; k2.hoehe = max( hoehe( k2.rechts ), k1.hoehe ) + 1; return k2; } /* * Doppelrotation der Binaerbaumknoten: : erster linker Nachfolgeknoten * mit seinem rechten Nachfolger; danach Knoten k3 mit neuem linken 239 Algorithmen und Datenstrukturen * Nachfolgerknoten. * Fuer AVL-Baeume ist dies eine doppelte Rotation (Fall 2) * Aktualisiert Angaben zur Hoehe,, danach Rueckgabe der neuen Wurzel. */ private static <T extends Comparable> GenAvlKnoten<T> doppelrotationMitLinksNachf(GenAvlKnoten<T> k3) { k3.links = rotationMitRechtsNachf( k3.links ); return rotationMitLinksNachf( k3 ); } /* * Doppelrotation der Binaerbaumknoten: erster rechter Nachfolgeknoten * mit seinem linken Nachfolger;danach Knoten k1 mit neuem rechten * Nachfolgerknoten * Fuer AVL-Baeume ist dies eine doppelte Rotation (Fall 3) * Aktualisiert Angaben zur Hoehe,, danach Rueckgabe der neuen Wurzel. */ private static <T extends Comparable> GenAvlKnoten<T> doppelrotationMitRechtsNachf(GenAvlKnoten<T> k1) { k1.rechts = rotationMitLinksNachf(k1.rechts); return rotationMitRechtsNachf(k1); } 2. Löschen Man kann folgende Fälle unterscheiden: (1) ∂H = +1 bzw. -1 (Verkürzung des Teilbaums auf der Überlastseite) (2) ∂H = 0 (Verkürzung eines Unterbaums) Der Knoten ist jetzt ungleichlastig ( ∂H = +1 bzw. -1), bleibt jedoch im Rahmen der AVL-Eigenschaft. Der Baum hat seine Höhe nicht verändert, die Berichtigung kann abgebrochen werden. (3) ∂H = +1 bzw. -1 (Verkürzung eines Baums auf der Unterlastseite) Die AVL-Eigenschaft ist verletzt, falls ∂H = +2 bzw. -2. Sie wird durch eine Einfachbzw. Doppelrotation wieder hergestellt. Dadurch kann sich der Baum verkürzen, so daß Lastreduzierungen an den Vorgänger weiterzugeben sind. Es können aber auch Lastsituationen mit dem Lastfaktor 0 auftreten. Bsp.: Spezialfälle zum Lastausgleich in einem AVL-Baum k k' H+2 H+1 k' a k c H+1 H+1 H H+1 b c a b 240 Algorithmen und Datenstrukturen k k'' H+1 H+2 k' a k k'' H H a b d H H Abb.: Löschen kann in der Regel nicht mit einer einzigen Rotation abgeschlossen werden. Im schlimmsten Fall erfordern alle Knoten im Pfad der Löschstelle eine Rekonfiguration. Experimente zeigen allerdings, daß beim Einfügen je Operation mehr Rotationen durchzuführen sind als beim Löschen. Offenbar existieren beim Löschen durch den inneren Bereich des Baums mehr Knoten, die ohne weiteres eliminiert werden können. Aufgabe 1. Gegeben ist die Schlüsselfolge 7, 6, 8, 5, 9, 4. Ermittle, wie sich mit dieser Schlüsselfolge einen AVL-Baum aufbaut. Schlüssel 7 BALANCE 0 LINKS, RECHTS 4 0 5 8 0 -1 6 0 9 0 Abb.: 2. Aus dem nun vorliegenden AVL-Baum sind die Knoten mit den Schlüsselwerten 9 und 8 zu löschen. Gib an, welche Gestalt der AVL-Baum jeweils annimmt. 241 Algorithmen und Datenstrukturen Schlüssel 5 BALANCE 1 LINKS, RECHTS 7 4 0 -1 6 0 Abb.: 3. Animation zur Demonstration der Funktionsweise von AVL-Bäumen 146 146 http://fbim.fh-regensburg.de/~saj39122/bruhi/index.html 242 Algorithmen und Datenstrukturen 4.3.3 Splay-Bäume Zugrundeliegende Idee Nachdem auf einen Baumknoten zugegriffen wurde, wird dieser Knoten über eine Reihe von AVL-Rotationen zur Wurzel. Bis zu einem gewissen Grade führt das zur Ausbalancierung. Bsp.: 1. y x x C A A y B B 2. e C e d F e d F d F c E c E b A a E a a D b A b c C D B B C C D A e a a F c c e d d A B F b A B b B E E C C D 243 D Algorithmen und Datenstrukturen Splaying-Operationen Der Knoten „x“ im Splay-Baum bewegt sich über einfache und doppelte Rotationen zur Wurzel. Man unerscheidet folgende Fälle: 1. (zig): x ist ein Kind der Wurzel von einem Splay-Baum, einfache Rotation 2. (zig-zig): x hat den Großvater g(x) und den Vater p(x), x und p(x) sind jeweils linke (bzw. rechte) Kinder ihres Vaters. g(x)=p(y) g(x) bzw. y = p(x) p(x) D A x x C A B B C D x y A z B C D 3. (zig-zag): x hat Großvater g(x) und Vater p(x), x ist linkes (rechtes) Kind von p(x), p(x) ist rechtes (linkes) Kind von g(x) z = g(x) x y=p(x) y z D x A B A B C 244 C D Algorithmen und Datenstrukturen Implementierung 147 BinaerBaumKnoten // Elementarer Knoten eines binaeren Baums, der nicht ausgeglichen ist // Der Zugriff auf diese Klasse ist nur innerhalb eines Verzeichnisses // bzw. Pakets moeglich class BinaerBaumknoten { // Instanzvariable protected BinaerBaumknoten links; // linker Teilbaum protected BinaerBaumknoten rechts; // rechter Teilbaum public Comparable daten; // Dateninhalt der Knoten // Konstruktor public BinaerBaumknoten(Comparable datenElement) { this(datenElement, null, null ); } public BinaerBaumknoten(Comparable datenElement, BinaerBaumknoten l, BinaerBaumknoten r) { daten = datenElement; links = l; rechts = r; } public void insert (Comparable x) { if (x.compareTo(daten) > 0) // dann rechts { if (rechts == null) rechts = new BinaerBaumknoten(x); else rechts.insert(x); } else // sonst links { if (links == null) links = new BinaerBaumknoten(x); else links.insert(x); } } public BinaerBaumknoten getLinks() { return links; } public BinaerBaumknoten getRechts() { return rechts; } } SplayBaum // // // // // // // // // // 147 SplayBaum class ***************** PUBLIC OPERATIONen ******************** void insert( x ) --> Insert x void remove( x ) --> Remove x Comparable find( x ) --> Gib das Merkmal zurück, das x zugeordnet ist Comparable findMin( ) --> Rueckgabe des kleinsten elements Comparable findMax( ) --> Rueckgabe des groessten Elements boolean isEmpty( ) --> Rueckgabe true, falls leer; sonst false void makeEmpty( ) --> Entferne alle Elemente pr43215 245 Algorithmen und Datenstrukturen // void printTree( ) --> Gib den Baum sortiert aus /* * Implementiere einen top-down Splay Baum. * Vergleiche beziehen sich auf die Methode compareTo. */ public class SplayBaum { private BinaerBaumknoten root; private static BinaerBaumknoten nullNode; static // Static initializer for nullNode { nullNode = new BinaerBaumknoten( null ); nullNode.links = nullNode.rechts = nullNode; } private static BinaerBaumknoten newNode = null; // wird in diversen Einfuegevorgaengen benutzt private static BinaerBaumknoten header = new BinaerBaumknoten(null); /* * Konstruktor. */ public SplayBaum( ) { root = nullNode; } /* * Zugriff auf die Wurzel */ public BinaerBaumknoten holeWurzel() { return root; } /* * Insert. * Parameter x ist das einzufuegende Element. */ public void insert( Comparable x ) { if( newNode == null ) newNode = new BinaerBaumknoten( null ); newNode.daten = x; if( root == nullNode ) { newNode.links = newNode.rechts = nullNode; root = newNode; } else { root = splay( x, root ); if( x.compareTo( root.daten ) < 0 ) { newNode.links = root.links; newNode.rechts = root; root.links = nullNode; root = newNode; } else if( x.compareTo( root.daten ) > 0 ) { newNode.rechts = root.rechts; newNode.links = root; root.rechts = nullNode; root = newNode; } else return; } newNode = null; 246 Algorithmen und Datenstrukturen } /* * Remove. * Parameter x ist das zu entfernende Element. */ public void remove( Comparable x ) { BinaerBaumknoten neuerBaum; // Falls x gefunden wird, liegt x in der Wurzel root = splay( x, root ); if( root.daten.compareTo( x ) != 0 ) return; // Element nicht gefunden; tue nichts if( root.links == nullNode ) neuerBaum = root.rechts; else { // Finde das Maximum im linken Teilbaum // Splay es zur Wurzel; dann haenge das rechte Kind dran neuerBaum = root.links; neuerBaum = splay( x, neuerBaum ); neuerBaum.rechts = root.rechts; } root = neuerBaum; } /* * Bestimme das kleinste Daten-Element im Baum. * Rueckgabe: kleinstes Datenelement bzw. null, falls leer. */ public Comparable findMin( ) { if( isEmpty( ) ) return null; BinaerBaumknoten ptr = root; while( ptr.links != nullNode ) ptr = ptr.links; root = splay( ptr.daten, root ); return ptr.daten; } /* * Bestimme das groesste Datenelement im Baum. * Rueckgabe: das groesste Datenelement bzw. null, falls leer */ public Comparable findMax( ) { if (isEmpty( )) return null; BinaerBaumknoten ptr = root; while( ptr.rechts != nullNode ) ptr = ptr.rechts; root = splay( ptr.daten, root ); return ptr.daten; } /* * Bestimme ein Datenelement im Baum. * Parameter x entfält das zu suchende Element. * Rueckgabe: Das passende Datenelement oder null, falls leer */ public Comparable find( Comparable x ) { root = splay( x, root ); if (root.daten.compareTo( x ) != 0) return null; return root.daten; } /* * Mache den Baum logisch leer. */ public void makeEmpty( ) { root = nullNode; } 247 Algorithmen und Datenstrukturen /* * Ueberpruefe, ob der Baum logisch leer ist * Rueckgabe true, falls leer, anderenfalls false. */ public boolean isEmpty( ) { return root == nullNode; } /* * Gib den Inhalt des baums in sortierter Folge aus. */ public void printTree( ) { if (isEmpty( )) System.out.println( "Empty tree" ); else printTree( root ); } /* * Ausgabe des Binaerbaums um 90 Grad versetzt */ public void ausgBinaerbaum(BinaerBaumknoten b, int stufe) { if (b != b.links) { ausgBinaerbaum(b.links,stufe + 3); for (int i = 0; i < stufe; i++) { System.out.print(' '); } System.out.println(b.daten.toString()); ausgBinaerbaum(b.rechts,stufe + 3); } } /* * Interne Methode zur Ausfuehrung eines "top down" splay. * Der zuletzt im Zugriff befindliche Knoten * wird die neue Wurzel. * Parameter x Ist das Zielelement, die Umgebung fuer das Splaying. * Parameter b ist die Wurzel des Teilbaums, * um den das Splaying stattfindet. * Rueckgabe des Teilbaums. */ private BinaerBaumknoten splay( Comparable x, BinaerBaumknoten t ) { BinaerBaumknoten leftTreeMax, rightTreeMin; header.links = header.rechts = nullNode; leftTreeMax = rightTreeMin = header; nullNode.daten = x; // Guarantee a match for( ; ; ) if( x.compareTo( t.daten ) < 0 ) { if( x.compareTo( t.links.daten ) < 0 ) t = rotateWithLeftChild( t ); if( t.links == nullNode ) break; // Kette Rechts rightTreeMin.links = t; rightTreeMin = t; t = t.links; } else if( x.compareTo( t.daten ) > 0 ) { if( x.compareTo( t.rechts.daten ) > 0 ) t = rotateWithRightChild( t ); if( t.rechts == nullNode ) break; // Kette Links 248 Algorithmen und Datenstrukturen leftTreeMax.rechts = t; leftTreeMax = t; t = t.rechts; } else break; leftTreeMax.rechts = t.links; rightTreeMin.links = t.rechts; t.links = header.rechts; t.rechts = header.links; return t; } /* * Rotation BinaerBaumknoten mit linkem Nachfolger. */ static BinaerBaumknoten rotateWithLeftChild(BinaerBaumknoten k2) { BinaerBaumknoten k1 = k2.links; k2.links = k1.rechts; k1.rechts = k2; return k1; } /* * Rotation BinaerBaumknoten mit rechtem Nachfolger. */ static BinaerBaumknoten rotateWithRightChild(BinaerBaumknoten k1) { BinaerBaumknoten k2 = k1.rechts; k1.rechts = k2.links; k2.links = k1; return k2; } /* * Interne Methode zur Ausgabe eines Teilbaums in sortierter Folge. * Parameter b ist der jweilige Wurzelknoten. */ private void printTree( BinaerBaumknoten b ) { if( b != b.links ) { printTree(b.links); System.out.println(b.daten.toString( )); printTree(b.rechts); } } } SplaybaumTest import java.io.*; public class SplayBaumTest { public static void main( String [ ] args ) { SplayBaum b = new SplayBaum(); String eingabeZeile = null; System.out.println("Einfuegen"); BufferedReader eingabe = null; eingabe = new BufferedReader( new InputStreamReader(System.in)); try { int zahl; do { System.out.println("Zahl? "); 249 Algorithmen und Datenstrukturen eingabeZeile = eingabe.readLine(); try { zahl = Integer.parseInt(eingabeZeile); b.insert(new Integer(zahl)); b.ausgBinaerbaum(b.holeWurzel(),2); } catch (NumberFormatException ne) { break; } } while (eingabeZeile != ""); } catch (IOException ioe) { System.out.println("Eingefangen in main()"); } System.out.println("Loeschen"); try { int zahl; do { System.out.println("Zahl? "); eingabeZeile = eingabe.readLine(); try { zahl = Integer.parseInt(eingabeZeile); b.remove(new Integer(zahl)); b.ausgBinaerbaum(b.holeWurzel(),2); } catch (NumberFormatException ne) { break; } } while (eingabeZeile != ""); } catch (IOException ioe) { System.out.println("Eingefangen in main()"); } System.out.println("Zugriff auf das kleinste Element"); b.findMin(); b.ausgBinaerbaum(b.holeWurzel(),2); System.out.println("Zugriff auf das groesste Element"); b.findMax(); b.ausgBinaerbaum(b.holeWurzel(),2); } } 250 Algorithmen und Datenstrukturen 4.4 Bayer-Bäume 4.4.1 Grundlagen und Definitionen 4.4.1.1 Ausgeglichene T-äre Suchbäume (Bayer-Bäume) Bayer-Bäume sind für die Verwaltung der Schlüssel zu Datensätzen in umfangreichen Dateien vorgesehen. Der binäre Baum ist für die Verwaltung solcher Schlüssel nicht geeignet, da er nur jeweils einen Knoten mit einem einzigen Datensatz adressiert. Die Daten (Datensätze) stehen blockweise zusammengefaßt auf Massenspeichern, der Binärbaum müßte Knoten für Knoten auf einen solchen Block abgebildet werden. Jeder Zugriff auf den Knoten des Baums würde ein Zugriff auf den Massenspeicher bewirken. Da ein Plattenzugriff relativ zeitaufwendig ist, hätte man die Vorteile der Suchbäume wieder verloren. In einen Knoten ist daher nicht nur ein Datum aufzunehmen, sondern maximal (T - 1) Daten. Ein solcher Knoten hat T Nachfolger. Die Eigenschaften der knotenorientierten "T-ären" Intervallbäume sind : - Jeder Knoten enthält max. (T - 1) Daten - Die Daten in einem Knoten sind aufsteigend sortiert - Ein Knoten enthält maximal T Teilbäume - Die Daten (Schlüssel) der linken Teilbäume sind kleiner als das Datum der Wurzel. - Die Daten der rechten Teilbäume sind größer als das Datum der Wurzel. - Alle Teilbäume sind T-äre Suchbäume. Durch Zusammenfassen mehrerer Knoten kommt man so vom binären zum "T-ären" Suchbaum, z.B.: 8 4 12 2 1 3 5 2 3 11 9 7 4 1 14 10 6 5 6 8 15 12 9 7 13 10 11 13 14 15 Abb. 4.4-1: T-äre Bäume haben aber noch einen schwerwiegenden Nachteil. Sie können leicht zu entarteten Bäumen degenerieren. 251 Algorithmen und Datenstrukturen Bsp.: Ein entarteter 5-ärer Baum enthält durch Eingabe (Einfügen) der Elemente 1 bis 16 in aufsteigender Folge folgende Gestalt: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Abb. 4.4-2: Durch Einfügen und Löschen können sich beliebig unsymetrische Strukturen herausbilden. Algorithmen zum Ausgleichen, vegleichbar mit den AVL-Rotationen sind jedoch nicht bekannt. Zunehmend an Bedeutung gewinnt ein höhengleicher Baum (B-Baum), der von R. Bayer eingeführt wurde. Höhengleichheit kann erreicht werden, wenn folgende Eigenschaften eingehalten werden: - Ein Knoten enthält höchstens 2 ⋅ M Schlüssel ( 2 ⋅ M + 1 -ärer Baum). Jeder Bayer-Baum (B-Baum) besitzt eine Klasse, im vorliegenden Fall die Klasse M. M heißt Ordnung des Baums 148. - Jeder Knoten (Ausname: Wurzel) enthält mindestens M Schlüssel, höchstens 2 ⋅ M Schlüssel. - Jeder Nichtblattknoten hat daher zwischen ( M + 1 ) und( 2 ⋅ M + 1 ) Nachfolger. - Alle Blattknoten liegen auf der gleichen Stufe. - B-Bäume sind von (a,b)-Bäumen abgeleitet. 148 In einigen Büchern wird als Ordnung des Baums der Verzweigungsgrad bezeichnet, hier also 2M+1 252 Algorithmen und Datenstrukturen 4.4.1.2 (a,b)-Bäume Ein (a,b)-Baum ist ein (externer) Suchbaum, für den gilt: - Alle Blätter haben die gleiche Tiefe - Schlüssel sind nur in den Blättern gespeichert 149. - Für alle Knoten k (außer Wurzeln und Blättern) gilt a ≤ Anzahl _ der _ Kinder (k ) ≤ b - b ≥ 2 ⋅ a −1 - Für alle inneren Knoten gilt: Hat k l Kinder, so sind in k l-1 Werte k1, ..., ki-1 gespeichert und es gilt: k i −1 ≤ key( w) ≤ k i für alle Knoten w im i-ten Unterraum von k . - Falls B ein (a.b)-Baum mit n Blättern ist, dann gilt log b ( n) ≤ n Höhe( B) ≤ 1 + log a ( ) . Der rechte 2 Teile der Ungleichung resultiert daraus, daß bei Bäumen mit Tiefe größer als 1 die Wurzel wenigstens zwei Kinder hat, eines der Kinder hat maximal n/2 Blätter und minimalen Verzweigungsgrad a. - B-Bäume sind Spezialfälle von (a.b)-Bäumen mit b = 2 ⋅ a − 1 Bsp.: 21, 39 7,15 32 1,4 1 71 9 4 7 9 17 15 17 52, 62 24 21 24 35 32 35 39 43,47 43 47 53,56 52 53 Abb. 4.4-3: (2,3) - Baum 2 1 1 3.4.5 2 3 4 5 Abb. 4.4-4: (2,4) - Baum 149 In dieser Sicht unterscheiden sich (a,b)-Bäume von den hier angesprochenen B-Bäumen. 253 56 67 62 67 Algorithmen und Datenstrukturen 4.4.2 Darstellung von Bayer-Bäumen +-----------------------------------+ | | | Z0S1Z1S2Z2S3 ........... ZN-1SNZN | | | +-----------------------------------+ Zl ... Zeiger Sl ... Schluessel Alle Schlüssel in einem Teilbaum, auf den durch Zl-1 verwiesen wird, sind kleiner als Sl. Alle Schlüssel in einem Unterbaum, auf den durch Zl verwiesen wird, sind größer als Sl. In einem B-Baum der Höhe H befinden sich daher zwischen N min = 2 ⋅ ( M + 1) H −1 − 1 und N max = 2 ⋅ ( M + 1) H − 1 Schlüssel. Neue Schlüssel werden stets in den Blättern zugefügt. Aufgabe: Gegeben ist die folgende Schlüsselfolge: „1, 7, 6, 2, 11, 4, 8, 13, 10, 5, 19, 9, 18, 24, 3, 12, 14, 20, 21, 17“. Bestimme die zugehörigen Strukturen eines 5-ären Baumes. 1) 1, 7, 6, 2 1 6 2 7 2) 11 6 1 2 7 11 7 8 3) 4, 8, 13 6 1 2 4 11 13 11 13 4) 10 6 1 2 4 10 7 8 5) 5, 19, 9, 18 254 Algorithmen und Datenstrukturen 6 1 2 4 5 10 7 8 9 18 19 11 13 11 13 19 24 13 14 19 20 6) 24 6 1 2 4 5 10 7 8 18 9 7) 3, 12, 14, 20, 21 1 2 4 5 3 6 7 8 10 9 18 11 12 21 24 Abb. 4.4-6: Java-Darstellung Zeiger ZI und Schlüssel SI eines jeden Knoten sind folgendermaßen angeordnet: +----------------------------- ------+ | | | Z0S0Z1S1Z2S2 ........... ZN-1SN-1ZN | | | +-------------------------------------+ Das führt zu der folgenden Beschreibung des B-Baums der Ordnung 2 (mit 5 Kettengliedern je Knoten). Die Klasse CBNode zeigt die Implementierung eines Bayer-Baumknotens 150. Der Konstruktor dieser Klasse leistet die Arbeit und bekommt dazu einen Übergabeparameter (M) geliefert, der die Ordnung des (M-ären) Bayer-Baums beschreibt. import java.util.*; /* * The CBNode class represents on single Node of the Bayer Tree. */ public class CBNode { // Instanzvariable protected Vector key, nodeptr, initkey, initvec; 150 Vgl. pr44200, CBNode.java 255 Algorithmen und Datenstrukturen int count; // Konstruktor /* * constructs a single Bayer Tree node with M references to subnodes. */ CBNode(int M) { // System.out.println("CBNode(): constructor invoked!"); nodeptr = new Vector(); initvec = new Vector(); initvec = null; key = new Vector(); initkey = new Vector(); initkey = null; for(int i = 0; i <= M; i++) { nodeptr.addElement((Object)initvec); System.out.println(i + "ter Nodepointer erzeugt. Wert: " + nodeptr.elementAt(i)); } for(int j = 0; j <= M - 1; j++) { key.addElement((Object)initkey); // System.out.println(j + "ter Key erzeugt. Wert: " + key.elementAt(j)); } count = 0; // System.out.println("count Wert: " + count); } } 4.4.3 Suchen eines Schlüssels Gegeben ist der folgende Ausschnitt eines B-Baums mit N Schlüsseln: +----------------------------- ------+ | | | Z0S0Z1S1Z2S2 ........... ZN-1SN-1ZN | | | +-------------------------------------+ S0<S1<S2<.....<SN-1 Handelt es sich beim Knoten um ein Blatt, dann ist der Wert eines jeden Zeigers ZI im Knoten NULL. Falls der Knoten kein Blatt ist, verweisen einige der (N+1) Zeiger auf andere Knoten (Kinder des aktuellen Knoten). I > 0: Alle Schlüssel im betreffenden Kind-Knoten, auf den ZI zeigt, sind größer als SI-1 I < N: Alle Schlüssel im betreffenden Kind, auf das ZI zeigt, sind kleiner als SN. Hat einer der angegebenen Zeiger den Wert „null“, dann existiert in dem vorliegenden Baum kein Teilbaum, der diesen Schlüssel enthält (d.h. die Suche ist beendet). Java-Implementierung Die Klasse CBayerTree umfaßt den Algorithmus 151 zum Einfügen und Löschen von Bayer-Baumknoten 151 Vgl. pr44200, CBayerTree.java 256 Algorithmen und Datenstrukturen class CBayerTree { // protected Instanzvariablen /* * Die Variable MAERER definiert die Ordnung des Bayer-Baums, * d.h. der Nachfolgerknoten bzw. Teilbäume eines Knoten * (max. MAERER). Jeder Knoten besteht aus MAERER Referenzen * auf Subknoten und MAERER - 1 Schlüsseln. */ protected int MAERER = 5; /* * contains the reference to the CVisualizeTree class. It will be set in * the constructor. */ protected CVisualizeTree mpCVisualizeTree; /* * contains the reference to the CExtendedCanvas class. It will be set in * the constructor. */ protected CExtendedCanvas mpCExtendedCanvas; /* * Referenz zum Wurzelknoten während der Lebensdauer des Baums. */ protected CBNode root; /* * speichert den neuen Schluessel, der in den baum eingefügt werden soll. */ protected Integer newValue; /* * Indikator fuer den Wurzelknoten. */ private int rootflag = 0; // Public Operationen // Der Konstruktor umfasst zwei Paramerte zur Visualisierung /* public CBayerTree(CExtendedCanvas pCExtendedCanvas, CVisualizeTree pCVisualizeTree); Einfuegen public int Insert(Integer value); ; Rueckgabe: -1, falls Fehlversuch; anderenfalls 0 Parameter: einzufuegender Schluessel Loeschen public int Delete(Integer delValue); ; Rueckgabe: -1, falls Fehlversuch; anderenfalls 0 Parameter: einzufuegender Schluessel public boolean searchkey(int key); Rueckgabe: true, falls der Schlüssel gefunden wurde; anderenfalls false Geschuetzte Methoden protected CBNode insrekurs(CBNode tempnode, Integer insValue); Private Methoden private int delrekurs(CBNode delNode, Integer value); ..... */ } /* Rueckgabe ist true, falls der Schlüssel gefunden wurde; anderenfalls false. */ public boolean searchkey(int key) { boolean found = false; int i = 0, n; CBNode node = root; while(node != null) 257 Algorithmen und Datenstrukturen { i = 0; n = node.count; // search key in actual node while(i < n && key > ((Integer)node.key.elementAt(i)).intValue()) { i++; } // end while if(i < n && key == ((Integer)node.key.elementAt(i)).intValue()) { found = true; } if(node.nodeptr.elementAt(i) != null) { mpCVisualizeTree.MoveLevelDown(i);} node = (CBNode) node.nodeptr.elementAt(i); } // end while (node != null) return found; } // end searchkey Methode 4.4.4 Einfügen Bsp.: Der Einfügevorgang in einem Bayer-Baum der Klasse 2 1) Aufnahme der Schlüssel 1, 2, 3, 4 in den Wurzelknoten 1 3 2 4 2) Zusätzlich wird der Schlüssel mit dem Wert 5 eingefügt 1 3 2 4 5 Normalerweise würde jetzt rechts von "4" ein neuer Knotem erzeugt. Das würde aber zu einem Knotenüberlauf führen. Nach dieser Erweiterung enthält der Knoten eine ungerade Zahl von Elementen ( 2 ⋅ M + 1 ). Dieser große Knoten kann in 2 Söhne zerlegt werden, nur das mittlere Element verbleibt im Vaterknoten. Die neuen Knoten genügen wieder den B-Baum-Eigenschaften und könnem weitere Daten aufnehmen. 3 1 2 4 5 Abb.: Beschreibung des Algorithmus für das Einfügen Ein neues Element wird grundsätzlich in einen Blattknoten eingefügt. Ist der Knoten mit 2 ⋅ M Schlüsseln voll, so läuft bei der Aufnahme eines weiteren Schlüssels der Knoten über. 258 Algorithmen und Datenstrukturen +---------------------------------------------+ | | | ........... SX-1ZX-1SXZX ..... | | | +---------------------------------------------+ +----------------------------------------------+ | | | Z0S1Z1 .... ZM-1SMZMSM+1 ....... Z2MS2M+1 | | Überlauf | +----------------------------------------------+ Abb.: Der Knoten wird geteilt: Die vorderen Schlüssel verbleiben im alten Knoten, der Schlüssel mit der Nummer M+1 gelangt als Trennschlüssel in den Vorgängerknoten. Die M Schlüssel mit den Nummern M+2 bis 2 ⋅ M + 1 kommen in den neuen Knoten. +-----------------------------+ | ....SX-1ZX-1SM+1ZYSXZX .... | +-----------------------------+ +------------------+ |Z0S1 .... ZM-1SMZM| +------------------+ +-----------------------------+ |ZM+1SM+2ZM+2 ..... S2M+1Z2M+1| +-----------------------------+ Abb.: Die geteilten Knoten enthalten genau M Elemente. Das Einfügen eines Elements in der vorangehenden Seite kann diese ebenfalls zum Überlaufen bringen und somit die Aufteilung fortsetzen. Der B-Baum wächst demnach von den Blättern bis zur Wurzel. Methoden zum Einfügen in Java /* *Einfügen eines neuen Schlüssels. Rückgabe ist –1, falls * es misslingt, anderenfalls 0 * Parameter: value einzufuegender Wert */ public int Insert(Integer value) { if(root == null) { root = new CBNode(MAERER); root.key.setElementAt((Object)value, 0); root.count = 1; } // end if else { if(searchkey(((Integer)value).intValue()) == true) { //System.out.println("double key found and will be ignored!"); return -1; } // end if CBNode result; result = insrekurs(root, value); if(result != null) { CBNode node = new CBNode(MAERER); node.key.setElementAt(newValue, 0); 259 Algorithmen und Datenstrukturen node.nodeptr.setElementAt(root, 0); node.nodeptr.setElementAt(result, 1); node.count = 1; root = node; } // end if(result) } // end else mpCVisualizeTree.DeleteRootKnot(); mpCExtendedCanvas.repaint(); rootflag = 0; this.drawTree(root); mpCExtendedCanvas.repaint(); return 0; } // end Insert() Methode Die Methode „Insert“ ruft „insrekurs()“ auf. Diese rekursive Methode leistet die eigentliche Arbeit /* * der neue Wert wird rekursiv in den Baum eingebracht */ protected CBNode insrekurs(CBNode tempnode, Integer insValue) { CBNode result; result = null; newValue = insValue; if(tempnode.nodeptr.elementAt(0) != null) // kein Blatt -> Rekursion { int pos = 0; while(pos < tempnode.count && newValue.intValue() > ((Integer)tempnode.key.elementAt(pos)).intValue()) { pos++; } // end while result = insrekurs((CBNode)tempnode.nodeptr.elementAt(pos), newValue); if(result == null) { return null; // if result = null: nothing has to be inserted into // node-> finished! } // end if(resul == null) } // end if(tempnode.nodeptr.elementAt(0) != null) // insert a element CBNode node = null; int flag = 0; int s = tempnode.count; if(s >= MAERER - 1) // split the knot { tempnode.count = (MAERER - 1) / 2; node = new CBNode(MAERER); node.count = (MAERER - 1) / 2; for(int d = ((MAERER - 1) / 2); d > 0;) { if(flag != 0 || ((Integer)tempnode.key.elementAt(s - 1)).intValue() > newValue.intValue()) { node.nodeptr.setElementAt(tempnode.nodeptr.elementAt(s), d); node.key.setElementAt(tempnode.key.elementAt(--s), --d); } // end if(flag != 0 ... else { node.nodeptr.setElementAt(result, d); node.key.setElementAt(newValue, --d); flag = 1; } // end else } // end if(s >= MAERER - 1) if(flag != 0 || ((Integer)tempnode.key.elementAt(s - 1)).intValue() > 260 Algorithmen und Datenstrukturen newValue.intValue()) { node.nodeptr.setElementAt(tempnode.nodeptr.elementAt(s), 0); } // end if else { node.nodeptr.setElementAt(result, 0); } // end else } // end if(s >= MAERER - 1) else { tempnode.count++; } // end else // shift for(; s > 0 && ((Integer)tempnode.key.elementAt(s - 1)).intValue() > newValue.intValue(); s--) { tempnode.nodeptr.setElementAt(tempnode.nodeptr.elementAt(s), s + 1); tempnode.key.setElementAt(tempnode.key.elementAt(s - 1), s); } // end for tempnode.key.setElementAt(newValue, s); tempnode.nodeptr.setElementAt(result, s + 1); newValue = (Integer) tempnode.key.elementAt((MAERER - 1) / 2); return node; } // end insrekurs() methode 4.4.5 Löschen Grundsätzlich ist zu unterscheiden: 1. Das zu löschende Element ist in einem Blattknoten 2. Das Element ist nicht in einem Blattknoten enthalten. In diesem Fall ist es durch eines der benachbarten Elemente zu ersetzen. Entlang des rechts stehenden Zeigers Z ist hier zum Blattknoten hinabzusteigen und das zu löschende Element durch das äußere linke Element von Z zu ersetzen. Auf jeden Fall darf die Anzahl der Schlüssel im Knoten nicht kleiner als M werden. Ausgleichen Die Unterlauf-Gegebenheit (Anzahl der Schlüssel ist kleiner als M) ist durch Ausleihen oder "Angliedern" eines Elements von einem der benachbarten Knoten abzustellen. Zusammenlegen Ist kein Element zum Angliedern übrig (, der benachbarte Knoten hat bereits die minimale Größe erreicht), dann enthalten die beiden Knoten je 2 ⋅ M − 1 Elemente. Beide Knoten können daher zusammengelegt werden. Das mittlere Element ist dazu aus den dem Knoten vorausgehenden Knoten zu entnehmen und der NachbarKnoten ist ganz zu entfernen. Das Herausnehmen des mittleren Schlüssels in der vorausgehenden Seite kann nochmals die Größe unter die erlaubte Grenze fallen lassen und gegebenenfalls auf der nächsten Stufe eine weitere Aktion hervorrufen. Bsp.: Gegeben ist ein 5-ärer B-Baum (der Ordnung 2) in folgender Gestalt: 261 Algorithmen und Datenstrukturen 50 30 10 20 35 40 60 42 38 44 46 56 58 65 80 70 90 95 Abb.: 1) Löschen der Schlüssel 44, 80 50 30 10 20 35 40 38 42 56 46 58 65 Abb.: 2) Einfügen des Schlüssels 99, Löschen des Schlüssels 70 mit Ausgleichen 50 30 40 10 20 35 38 60 42 46 90 60 56 58 Abb.: 262 95 65 90 96 99 70 95 96 96 Algorithmen und Datenstrukturen 3) Löschen des Schlüssels 35 mit Zusammenlegen 50 40 10 20 30 60 38 42 46 56 58 95 65 90 96 99 65 90 96 99 Abb.: 40 10 20 30 38 42 46 50 60 95 56 58 Abb.: Löschen eines Schlüssels im Blattknoten 1. Fall: Im Blattknoten befinden sich mehr als die kleinste zulässige Anzahl von Schlüsselelementen. Der Schlüssel kann einfach entfernt werden, die rechts davon befindlichen Elemente werden einfach eine Position nach links verschoben. 2. Fall: Das Blatt enthält genau nur noch die kleinste zulässige Anzahl von Schlüsselelementen, Nachbachknoten auf der Ebene der Blattknoten enthalten mehr als die kleinste zulässige Anzahl von Schlüsselelementen. Der Schlüssel wird gelöscht, im Blatt liegt dann ein „Unterlauf“ vor. Man versucht aus den linken oder rechten Nachbarknoten ein Element zu besorgen, z.B.: Es liegt im Anschluß an einen (rekursiven) Aufruf, der in einem Blattknoten einen Schlüssel entfernt hat, folgende Situation vor: 20 10 12 30 15 40 25 33 34 36 46 48 Abb.: Die Entnahme geeigneter Schlüssel kann hier aus dem linken bzw. aus dem rechten Nachbarn vom betroffenen Knoten erfolgen: 20 10 12 15 33 40 25 30 34 36 Abb.: 263 46 48 Algorithmen und Datenstrukturen Falls vorhanden, soll immer der rechte Nachbarknoten gewählt werden. Im vorliegenden Beispiel ist das nicht möglich beim Löschen der Schlüsselwerte „46“ bzw. „48“. In solchen Fällen wird dem Linken Knoten ein Element entnommen. 3. Fall: Das Blatt enthält genau die kleinste mögliche Anzahl an Elementen, Nachbarknoten auf der Ebene der Blattknoten enthalten auch nur genau die kleinste mögliche Anzahl an Elementen. In diesem Fall müssen die betroffenen Knoten miteinander verbunden werden, z.B. liegt im Anschluß an einen Aufruf, der in einem Blattknoten einen Schlüssel entfernt hat, folgende Situation vor: 20 10 30 12 15 40 25 34 36 46 48 Die Verbindung zu einem Knoten mit zulässiger Anzahl von Schlüsselelementen kann so vollzogen werden: 20 10 12 40 15 25 30 34 36 46 48 Abb.: Löschen eines Schlüssels in einem inneren Knoten Solches Löschen kann aus einem Löschvorgang in einem Blattknoten resultieren. Bsp.: 15 3 1 2 4 6 5 20 10 12 18 19 60 22 30 70 80 22 70 80 Abb.: Das Löschen vom Schlüssel mit dem Wert 1 ergibt: 6 2 3 4 5 10 15 12 20 60 18 19 30 Abb.: Im übergeordneten Knoten kann es erneut zu einer Unterlauf-Gegebenheit kommen. Es ist wieder ein Verbinden bzw. Borgen mit / von Nachbarknoten erforderlich, bis man schließlich an der Wurzel 264 Algorithmen und Datenstrukturen angelangt ist. Im Wurzelknoten kann nur ein Element sein. Wird dieses Element in den Verknüpfungsvorgang der beiden unmittelbaren Nachfolger einbezogen, dann wird der Wurzelknoten gelöscht, die Höhe des Baums nimmt ab. Eine Löschoperation kann auch direkt in einem internen Knoten beginnen, z.B. wird im folgenden Bayer-Baum im Wurzelknoten der Schlüssel mit dem Wert „15“ gelöscht. 15 3 1 2 4 6 5 20 10 12 18 19 60 22 30 70 80 Abb.: Zuerst wird zum linken Nachfolger gewechselt, anschließend wird der Baum bis zum Blatt nach rechts durchlaufen. In diesem Blatt wird dann das am weitesten rechts stehenden Datum aufgesucht und mit dem zu löschenden Element im Ausgangsknoten getauscht. 12 3 1 2 4 6 5 20 10 15 18 19 60 22 30 70 80 Abb.: Der Schlüssel mit dem Wert „15“ kann jetzt nach einer bereits beschriebenen Methode gelöscht werden. Implementierung in Java Grundsätzlich ist zu unterscheiden: 1. Das zu löschende Element ist in einem Blattknoten 2. Das Element ist nicht in einem Blattknoten enthalten. In diesem Fall ist es durch eines der benachbarten Elemente zu ersetzen. Entlang des rechts stehenden Zeigers Z ist hier zum Blattknoten hinabzusteigen und das zu löschende Element durch das äußere linke Element von Z zu ersetzen. Auf jeden Fall darf die Anzahl der Schlüssel im Knoten nicht kleiner als M werden. /* * loescht einen Schlüssel. Rückgabe ist * anderenfalls 0. * Parameter: zu löschender Wert */ public int Delete(Integer delValue) 265 -1, falls es misslingt; Algorithmen und Datenstrukturen { mpCVisualizeTree.MoveToRoot(); if(searchkey(((Integer)delValue).intValue()) == false) { return -1; } // end if if(delrekurs(root, delValue) == 0) { CBNode temp = root; root = (CBNode)root.nodeptr.elementAt(0); temp = null; } // end if mpCVisualizeTree.DeleteRootKnot(); mpCExtendedCanvas.repaint(); rootflag = 0; this.drawTree(root); mpCExtendedCanvas.repaint(); return 0; } // end Delete() Methode Die eigentliche Arbeit beim Löschen übernimmt die rekursive Methode „delrekurs()“ /* deletes the value rekursively from the tree. * private int delrekurs(CBNode delNode, Integer value) { int result = 0, pos, found = 0; Vector nullVec = new Vector(); nullVec = null; if(delNode != null) { CBNode node; for(pos = 0; pos < delNode.count; pos++) { if(value.intValue() <= ((Integer)delNode.key.elementAt(pos)).intValue()) { if(value.intValue() < ((Integer)delNode.key.elementAt(pos)).intValue()) { result = delrekurs((CBNode)delNode.nodeptr.elementAt(pos), (Integer)value); } // end if else { if(delNode.nodeptr.elementAt(0) == null) // leaf node! { for(; (pos + 1) < delNode.count; pos++) { delNode.key.setElementAt(delNode.key.elementAt(pos + 1), pos); } // end for //System.out.println("Ende weil Blatt!"); return --delNode.count; } // end if else { node = (CBNode)delNode.nodeptr.elementAt(pos + 1); while(node.nodeptr.elementAt(0) != null) { node = (CBNode)node.nodeptr.elementAt(0); } // end while delNode.key.setElementAt(node.key.elementAt(0), pos); //System.out.println("Tausch, loesche rechts"); pos++; result = delrekurs((CBNode)delNode.nodeptr.elementAt(pos), (Integer)delNode.key.elementAt(pos - 1)); } // end else } // end else 266 Algorithmen und Datenstrukturen found = 1; break; } // end if } // end for if(found == 0) { result = delrekurs((CBNode)delNode.nodeptr.elementAt(pos), (Integer)value); } // end if if(result < ((MAERER - 1) / 2)) { CBNode temp; int l = 0, r = 0; if(pos > 0) { l = ((CBNode)delNode.nodeptr.elementAt(pos - 1)).count; } // end if if(pos < delNode.count) { r = ((CBNode)delNode.nodeptr.elementAt(pos + 1)).count; } // end if node = (CBNode)delNode.nodeptr.elementAt(pos); if(l > (MAERER - 1) / 2) // steal a key from left { //System.out.println("klaue einen Schluessel von links"); temp = (CBNode)delNode.nodeptr.elementAt(pos - 1); for(int i = node.count; i > 0; i--) { node.key.setElementAt(node.key.elementAt(i - 1), i); node.nodeptr.setElementAt(node.nodeptr.elementAt(i), i + 1); } // end for node.nodeptr.setElementAt(node.nodeptr.elementAt(0), 1); node.count++; node.key.setElementAt(delNode.key.elementAt(pos - 1), 0); node.nodeptr.setElementAt(temp.nodeptr.elementAt(temp.count), 0); delNode.key.setElementAt(temp.key.elementAt(--temp.count), pos - 1); } // end if else { if(r > (MAERER - 1) / 2) // steal a key from right { // System.out.println("klaue Schluessel von rechts"); temp = (CBNode)delNode.nodeptr.elementAt(pos + 1); node.key.setElementAt(delNode.key.elementAt(pos), node.count); node.count++; node.nodeptr.setElementAt(temp.nodeptr.elementAt(0), node.count); delNode.key.setElementAt(temp.key.elementAt(0), pos); for(int i = 1; i < temp.count; i++) { temp.key.setElementAt(temp.key.elementAt(i), i - 1); temp.nodeptr.setElementAt(temp.nodeptr.elementAt(i), i - 1); } // end for temp.nodeptr.setElementAt(temp.nodeptr.elementAt(temp.count), temp.count - 1); temp.count--; } // end if else { //System.out.println("Knoten verschmelzen !"); if(r == 0) { pos--; } // end if node = (CBNode)delNode.nodeptr.elementAt(pos); temp = (CBNode)delNode.nodeptr.elementAt(pos + 1); node.key.setElementAt(delNode.key.elementAt(pos), node.count++); node.nodeptr.setElementAt(temp.nodeptr.elementAt(0), node.count); for(int i = 0; i < temp.count; i++) { 267 Algorithmen und Datenstrukturen node.key.setElementAt(temp.key.elementAt(i), node.count++); node.nodeptr.setElementAt(temp.nodeptr.elementAt(i + 1), node.count); } // end for // System.out.println( // "Jetzt kann der Knoten rechts daneben entfernt werden!"); delNode.count--; // delNode.nodeptr.elementAt(pos + 1) = null; // geht das so? delNode.nodeptr.setElementAt((Object)nullVec, pos + 1); while(pos < delNode.count) { delNode.key.setElementAt(delNode.key.elementAt(pos + 1), pos); pos++; delNode.nodeptr.setElementAt(delNode.nodeptr.elementAt(pos + 1), pos); } // end while } // end else } // end else } // end if return delNode.count; } // end if else { return 0; } // end else } // end delrekurs() Methode 4.4.6 Demonstration eines 3ären bzw. 5ären Bayer-Baums Mit dem Aufruf der folgenden HTML-Seite 152 kann ein Java-Applet gestartet werden, das 3äre bzw. 5äre Bäume darstellt. 152 http://fbim.fh-regensburg.de/~saj39122/AD/index.html 268 Algorithmen und Datenstrukturen 269 Algorithmen und Datenstrukturen 4.4.6 Auf Platte/ Diskette gespeicherte Datensätze Der Ausgangspunkt zu B-Bäumen war die Verwaltung der Schlüssel zu Datensätzen in umfangreichen Dateien. In der Regel will man ja nicht nur einfache Zahlen (d.h. einzelne Daten), sondern ganze Datensätze speichern. Eine größere Anzahl von Datensätzen einer solchen Datei ist aber im Arbeitsspeicher (, der ja noch Teile des Betriebssystems, das Programm etc. enthalten muß,) nicht unterzubringen. Notwendig ist die Auslagerung von einem beträchtlichen Teil der Datensätze auf einen externen Speicher. Dort sind die Datensätze in einer Datei gespeichert und in "Seiten" zusammengefaßt. Eine Seite umfaßt die im Arbeitsspeicher adressierbare Menge von Datensätzen (Umfang entspricht einem Bayer-Baumknoten). Aus Vergleichsgründen soll hier die Anzahl der aufgenommenen bzw. aufzunehmenden Datensätze die Zahl M = 2 nicht überschreiten. Es werden also mindestens 2, im Höchstfall 4 Datensätze in eine Seite aufgenommen. Allgemein gilt: Je größer M gewählt wird, umso mehr Arbeitsspeicherplatz wird benötigt, um so größer ist aber auch die Verarbeitungsleistung des Programms infolge der geringeren Anzahl der (relativ langsamen) Zugriffsoperationen auf externe Speicher. Die 1. Seite der Datei (Datenbank) enthält Informationen für die Verwaltung. Implementierung in C++ Die Verwaltung eines auf einer Datei hinterlegten Bayer-Baums übernimmt die folgende Klasse BBaum: #define MAERER 5 // Anzahl Verkettungen im Bayer-Baum Knoten enum status {unvollstaendigesEinfuegen, erfolgreich, doppelterSchluessel, Unterlauf, nichtGefunden}; typedef int dtype; // Knoten eines auf einer Datei hinterlegten Bayer-Baums. struct knoten { int n; // Anzahl der Elemente, die in einem Knoten // Knoten gespeichert sind (n < MAERER) dtype s[MAERER-1]; // Datenelemente (aktuell sind n) long z[MAERER]; // 'Zeiger' auf andere Knoten (aktuell sind n+1) }; // Logische Ordnung: // z[0], s[0], z[1], s[1], ..., z[n-1], s[n-1], z[n] // Die Klasse zum auf einer Datei hinterlegten Bayer-Baum class BBaum { private: enum {NIL=-1}; long wurzel, freieListe; knoten wurzelKnoten; fstream datei; status einf(long w, dtype x, dtype &y, long &u); void ausg(long w, int nLeer); int knotenSuche(dtype x, const dtype *a, int n)const; status loe(long w, dtype x); void leseKnoten(long w, knoten &Knoten); void schreibeKnoten(long w, const knoten &Knoten); 270 Algorithmen und Datenstrukturen void leseStart(); long holeKnoten(); void freierKnoten(long w); public: BBaum(const char *BaumDateiname); ~BBaum(); void einfuegen(dtype x); void einfuegen(const char *eingabeDateiname); void gibAus(){cout << "Dateninhalt:\n"; ausg(wurzel, 0);} void loeschen(dtype x); void zeigeSuche(dtype x); }; Zur Verwaltung des Bayer-Baums in einer Datei ist besonders wichtig: - Die Wurzel wurzel (d. h. die Position des Wurzelknotens - eine Liste mit Informationen über den freien Speicherplatz in der Datei (adressiert über freieListe). Zu solchen freien Speicherplätzen kann es beim Löschen von Schlüsselelementen kommen. Zweckmäßigerweise wird dann dieser freie Speicherbereich nicht aufgefüllt, sondern in einer Liste freier Speicherbereiche eingekettet. freieListe zeigt auf das erste Element in dieser Liste. Solange das Programm läuft sind „wurzel“ und „freieListe“ Datenelemente der Klasse BBaum (in einer Datei abgelegter Bayer-Baum). Für die Belegung dieser Dateielemente wird am Dateianfang (1.Seite) Speicherplatz reserviert. Am Ende der Programmausführung werden die Werte zu „wurzel“ bzw. „freieListe“ in der Datei abgespeichert. Bsp.: Der folgende Bayer-Baum 20 10 15 60 80 10 wurzel 15 60 80 20 freieListe Abb.: Zeiger haben hier ganzzahlige Werte des Typs long (mit -1L als NIL), die für die Positionen und Bytenummern stehen. 271 Algorithmen und Datenstrukturen 4.4.7 B*-Bäume Der B*-Baum entspricht einer geketteten sequentiellen Datei von Blättern, die einen Indexteil besitzt, der selbst ein B-Baum ist. Im Indexteil werden insbesondere beim Split-Vorgang die Operationen des B-Baums eingesetzt. Hauptunterschied zu B-Bäumen: im inneren Knoten wird nur die Wegweiser-Funktion ausgenutzt: - innere Knoten führen nur (Si,Zi) als Einträge. - Information (Si,Di) wird in den Blattknoten abgelegt. Dabei werden alle Schlüssel mit ihren zugehörigen Daten in Sortierreihenfolge in den Blättern abgelegt. - Für einige Si ergibt sich redundante Speicherung. Die inneren Knoten bilden einen Index, der einen schnellen direkten Zugriff zu den Schlüsseln ermöglicht. - Durch Verkettung aller Blattknoten lässt sich eine effiziente sequentielle Verarbeitung erreichen . 12 . .2.5.9. 1 2 3 4 5 6 7 8 9 Abb.: B*-Baum der Klasse . 15 . 18 . 20 . 10 11 12 13 14 15 16 17 18 19 20 21 22 23 τ (2,2,3) Definition. k, k* >0 und h* >= 0 sind ganze Zahlen. Ein B*-Baum der Klasse τ (k , k *, h*) ist entweder ein leerer Baum oder ein geordneter Baum, für den gilt: 1. Jeder Pfad von der Wurzel zu einem Blatt besitzt die gleiche Länge h* - 1. 2. Jeder Knoten außer der Wurzel und den Blättern hat mindestens k + 1 Söhne, die Wurzel hat mindestens 2 Söhne, außer wenn sie ein Blatt ist. 3. Jeder innere Knoten hat höchstens 2k + 1 Söhne. 4. Jeder Blattknoten mit Ausnahme der Wurzel als Blatt hat mindestens k* und höchstens 2k* Einträge Unterscheidung zwischen zwei Knotenformaten: l M . S1 . innere Knoten k <=b <=2k Z0 Blattknoten k*<=m<=2k* ......... Z1 Zb M . . S1D1 S2D2 Zp Sb . freier Platz .... SmDm freier Platz Zn M: enthält Kennung des Seitentyps sowie Zahl der aktuellen Einträge Abb. Knotenformate im B*-Baum Bestimmen von k bzw. k* 272 Algorithmen und Datenstrukturen l = l M + l z + 2 ⋅ k ⋅ (l z + l S ) , k = l − lM − lz 2 ⋅ (l S +l z ) l − lM − 2 ⋅ l z 2 ⋅ (l S +l D ) l = l M + 2 ⋅ l z + 2 ⋅ k * ⋅(l S + l D ) ; k * = Höhe des B*-Baums: 1 + log 2 k +1 ( n n ) ≤ h* ≤ 2 + log k +1 ( ) für h* >= 2 2k * 2k * Minimale bzw. maximale Anzahl von Knoten. nmin = 2 ⋅ k * ⋅(k + 1) h*−2 nmax = 2 ⋅ k * ⋅(2k + 1) h*−1 Operationen. B*-Baum entspricht einer geketteten sequentiellen Datei von Blättern, die einen Indexteil besitzt, der selbst ein B-Baum ist. Im Indexteil werden insbesondere beim Split-Vorgang, die Operationen des B-Baums eingesetzt. Grundoperationen beim B*-Baum. (1) Direkte Suche: Da alle Schlüssel in den Blättern sind, kostet jede direkte Such h* Zugriffe. h* ist jedoch im Mittel kleiner als h in B-Bäumen. (2) Sequentielle Suche: Sie erfolgt nach Aufsuchen des Linksaußen der Struktur unter Ausnutzung der Verkettung der Blattseiten. Es sind zwar gegebenenfalls mehr Blätter als beim B-Baum zu verarbeiten, doch da nur h*-1 innere Knoten aufzusuchen sind, wird die sequentielle Suche effizienter ablaufen. (3) Einfügen: Von Durchführung und Leistungsverhalten dem Einfügen von BBäumen sehr ähnlich. Bei inneren Knoten wird die Spaltung analog zum B-Baum durchgeführt. Beim Split-Vorgang einer Basis-Seite muß gewährleistet sein, dass jeweils der höchste Schlüssel einer Seite als Wegweiser in den Vaterknoten kopiert werden. S2k* S1D1 .... Sk*Dk* Sk*+1Dk*+1 ... S2k*D2k* SD Sk* S2k* S1D1 … Sk*Dk* Sk*+1Dk*+1 … SD … S2k*D2k* Bsp.: In den folgenden B*-Baum soll der Schlüssel 45 (einschl. Datenteil) eingefügt werden. 273 Algorithmen und Datenstrukturen 12 28 46 67 1 5 9 12 15 19 28 33 37 41 46 53 59 67 71 83 99 41 12 28 1 5 9 12 15 19 46 67 28 33 37 Abb.: Einfügen in einen B*-Baum der Klasse 41 45 46 53 59 67 71 83 99 τ (2,2,3) (4) Löschen: Datenelemente werden immer von einem Blatt entfernt (keine komplexe Fallunterscheidung wie beim B-Baum). Weiterhin muß beim Löschen eines Schlüssels aus einem Blatt dieser Schlüssel nicht aus dem Indexteil entfernt werden, er behält seine Funktion als Wegweiser. Bsp.: Löschen der Schüssel 28, 41, 46 (einschl. der zugehörigen Datenteile) im zuletzt angegebenen B*-Baum der Klasse τ ( 2,2,3) 41 12 28 1 5 9 12 15 19 53 67 28 33 37 Abb.: Löschen in einen B*-Baum der Klasse 45 53 τ (2,2,3) 274 59 67 71 83 99 Algorithmen und Datenstrukturen 4.5 Digitale Suchbäume Bei B-Bäumen führen variabel lange Zeichenketten zu Problemen. Falls der im Baum zu verteilende Inhalt eine insgesamt relativ statische Struktur hat, dann kann diese Struktur selbst die Schlüsselwerte (z.B. als Präfixfolge) bilden. Die dabei entstehende Baumstruktur ist wiederun ein Mehrwegbaum, der aufgrund einer möglichen Schlüsselwertunterteilungsform digital genannt wird. 4.5.1 Grundlagen und Definitionen Ein digitaler Suchbaum (Digital Search Tree) ist eine Baumstruktur für die Datenspeicherung und –suche, bei der die Schlüsselwerte die Anfangswertteile der Daten selbst darstellen. Diese Datenteile werden im allg. als Kantenbewegungen visualisiert und implementiert. Konkrete Formen digitaler Bäume sind der Trie und der Patricia-Baum. Der Trie leitet seine Bezeichnung von Information Retrieval ab 153. Diese Baumstruktur eignet sich insbesondere für eine effiziente Suche in Zeichenketten, bei dem die ersten Zeichen den jeweiligen Suchbegriff bzw. Schlüsselwert darstellen. Die Konkatenation der jeweiligen Schlüsselwerte ergibt dann den Präfix der gesuchten Zeichenkette. Der Patricia-Baum hat seine Bezeichnung von dem Akronym "Practical Algorithm To Retrieve Information Coded in Alphanumeric". Sein Prinzip ist die Möglichkeit des "Überspringens" von Teilworten im Suchbaum. Das wird dadurch erreicht, dass Präfixinhalte in den Suchknoten selbst gespeichert werden. Das Prinzip digitaler Suchbäume ist - Zerlegung des Schlüssels – bestehend aus Zeichen eines Alphabets – in Teile - Aufbau des Baums nach Schlüsselteilen - Suche im Baum durch Vergleich von Schlüsselteilen - Jede unterschiedliche Folge von Teilschlüsseln ergibt eigenen Suchweg im Baum - Alle Schlüssel mit dem gleichen Präfix haben in der Länge des Präfix den gleichen Suchweg. - vorteilhaft u.a. bei variabel langen Schlüsseln, z.B. Strings Schlüssselteile können gebildet werden durch Elemente (Bits, Zeichen, Ziffern) eines Alphabets oder durch Zusammenfassungen dieser Grundelemente (z.B. Silben der Länge k). l + 1 , wenn l die maximale Die Höhe des Baums (z.B. Silben der Länge k) ist k Schlüssellänge und k die Schlüsselteillänge ist. 153 wird aber wie "try" gesprochen 275 Algorithmen und Datenstrukturen 4.5.2 Tries Ein Trie ist eine auf Bäumen basierte Datenstruktur, um Worte (strings) zu speichern. Auf Tries lässt sich schnelles pattern matching anwenden. Darau ergibt sich die Hauptanwendung von Tries, das Wiedererlangen (retrieval) von Informationen. Tries sind spezielle m-Wege-Bäume, wobei Kardinalität und Länge k der Schlüsselteile den Grad m festlegen. Standard-Tries Definition: Falls S sine Menge von k Strings ist im Alphabet Σ ist, dann ist eine Standard Trie ein geordneter Baum T mit folgenden Eigenschaften: 1. Jeder Knoten von T – mit Ausnahne der Wurzel – ist mit einem Zeichen von Σ versehen. 2. Kinder eines internen Knotens sind kanonisch angeordnet. 3. Kein String in S ist Präfix eines anderen Strings. 4. T besitzt k externe Knoten, die jeweils einen String von S repräsentieren. Die Aneinanerreihung der Knotenbezeichnungen auf dem Weg von der Wurzel zu einem externen Knoten v von T ergibt den String von S, den v repräsentiert. Bsp.: Standard-Trie für die Strings {ANGEL, ART, AUTO, BUS, BUSCH} (Alphabet Σ = Großbuchstaben A ... Z. A B R N U U T G T S O C E S L T H Zwar scheinen im obigen Bsp. die Punkte 3 (da {BUS , BUSCH } ∈ S ) und 4 (da k = 6, aber T nur 5 externen Knoten besitzt) aus der Definition verletzt zu sein, jedoch kann der Trie auch dargestellt werden, indem jedem String aus S ein zusätzliches, nicht in Σ enthaltendes Zeichen - z.B. $ hinzugefügt wird, das das Ende des Strings repräsentiert. Im obigen Bsp. ist ein Knoten, an dem ein String endet, als eckiger Knoten dargestellt 154. Einfügen (insert()) für einen String s[1..n] in einen Trie: public void insert(Trie t, String s) // der aktuelle Knoten Ist die Wurzel { for (int n = 0; n < s.length(); n++) { int index = s.charAt(n) – 'a'; if (t.next[index] == null) 154 von t) // Ueberpruefe fuer alle s[i] ... // .. ob der aktuelle Knoten einen // Zeiger auf Knoten besitzt, der entspricht in der Implementierung dem Setzen eines Flags isWord 276 Algorithmen und Datenstrukturen { t.next[index] = new Trie(); } t = t.next[index]; } t.isWord = true; } // // // // // // s[i] repraesentiert. Falls nicht fuege diesen Knoten ein Setze den aktuellen Knoten auf eben dieses Kind des aktuellen Knotens Setze beim Knoten, der s[n] repraesentiert, das Flag isWord. insert() besitzt eine Laufzeit O(n), wobei n die Länge des einzufügenden String ist. Suchen (search()) nach dem Vorhandensein eines Strings s[1..n]: public boolean search(Trie t, String s) // der aktuelle Knoten Ist die Wurzel von t) { for (int n = 0; n < s.length();n++) // Ueberpruefe fuer alle s[j] .. { int index = s.charAt(n) – 'a'; // .. ob der aktuelle Knoten einen if (t.next[index] == null) // Zeiger auf Knoten besitzt, der { // s[i] repraesentiert. Falls nicht, return false; // gib false zurueck } // Setze den aktuellen Knoten auf t = t.next[index]; // eben dieses Kind des aktuellen Knotens } // Gib beim Knoten, der s[n] repraesent.isWord = true; // tiert, das Flag isWord zurueck. } Das Suchen eines Strings s der Länge n in Standard Tries lässt sich in O(n) realisieren Präfix-Suche (isPrefix()) zur Überprüfung auf das Vorhandensein eines Präfix: Die Präfix-Suche entspricht der Implementierung des search()-Algorithmus mit dem einzigen Unterschied, dass die Rückgabe von isWord durch return true ersetzt wird. Überprüfen, ob ein Knoten t eines Standard Tries extern 155 ist, durch isEmpty(): public boolean isEmpty(Trie t) { for (int d = 0; d < ALPH – 1; d++) // Ueberpruefe fuer alle ALPH − Σ Zeiger, ob diese auf null ges. sind. if (t.next[d] != null) return false; // Falls nicht, gebe false … return true; // sonst true zurueck } Falls d die Länge des zugrundeliegenden Alphabets Σ ist, besitzt isEmpty() eine Laufzeit von O(d). Löschen (delete()) eines Strings s aus einem Standard Trie t: public void delete(Trie t,String s) { if (!search(s)) // Ueberpruefe zunaechst, ob der zu loeschende String { // im Trie vorhanden ist return; // falls nicht, rufe doDelete auf } doDelete(s,0,t,t.next[charAt(0) – 'a']); } void doDelete(String s, int n, Trie prev, Trie current) { if (n < s.length() – 1)) // gehe zuerst rekursiv zum Knoten, der s[n] { // repraesentiert 155 d.h. alle Zeiger dieses Knotens sind auf Null gesetzt. 277 Algorithmen und Datenstrukturen doDelete(s,(n+1),current,current.next[s.charAt(n+1)-'a']); } if (n == s.length() – 1) current.isWord = false; // Loesche an diesem Knoten das Flag if (current.isEmpty() && (current.isWord == false)) // Ist dieser Knoten prev.next[s.charAt(k)-'a'] = null; // extern und repraesentiert keinen } // keinen String aus s,loesche ihn und verfahre dann analog mit den // darueberliegenden Knoten. delete() besitzt eine Laufzeit von O(d – n), wobei n die Länge von s und d die Länge von Σ ist. m-äre Tries Definition: Ein m-ärer Trie ist ein spezieller m-Wege-Baum, wobei Kardinalität des Alphabets und Länge k der Schlüsselteile den Grad festlegen - bei Ziffern: m = 10 - bei Alpha-Zeichen: m = 26; bie alphanumerischen Zeichen: m = 36 - bei Schlüsselteilen der Länge k potenziert sich der Grad, d.h. als Grad ergibt sich mk. Darstellung - Jeder Knoten eines Tries vom Grade m ist im Prinzip ein eindimensionale Vektor mit m Zeigern - Jedes Element im Vektor ist einem Zeichen (bzw. Zeichenkombination) zugeordnet. Auf diese Weise wird ein Schlüsselteil (Kante) implizit durch die Vektorposition ausgedrückt P0 P1 P2 P3 P4 P5 P6 P7 P8 P9 m=10 k=1 Abb.: Knoten eines 10-ären Tries mit Ziffern als Schlüsselteilen - implizite Zuordnung von Ziffer / Zeichen zu Zeiger (Referenz) Pi gehört zur Ziffer i. Tritt Ziffer i in der betreffenden Position auf, so verweist Pi auf den Nachfolgerknoten. Kommt i in der betreffenden Position nicht vor, so ist Pi mit NULL belegt. - Falls der Knoten auf der j-ten Stufe eines 10-ären Tries liegt, dann zeigt Pi auf einen Unterbaum, der nur Schlüssel enthält, die in der j-ten Position die Ziffer i besitzen. Bsp.: Trie für Schlüssel aus einem auf A – E beschränkten Alphabet $ 156 A B C D E m=6 k=1 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Abb. Trie für Schlüssel aus einem auf A … E beschränkten Alphabet. 156 Trennzeichen: kennzeichnet Schlüsselende 278 * * * * * * * * * * * * Algorithmen und Datenstrukturen Grundoperationen. Direkte Suche: In der Wurzel wird nach dem 1. Zeichen des Suchschlüssels verglichen. Bei Gleichheit wird der zugehörige Zeiger verfolgt. Im gefundenen Knoten wird nach dem 2. Zeichen verglichen usw. Aufwand bei erfolgreicher Suche: li . k Löschen: Nach dem Aufsuchen des richtigen Knoten wird ein *-Zeiger auf NULL gesetzt. Besitzt daraufhin der Knoten nur NULL-Zeiger, wird er aus dem Baum entfernt 4.5.3 Binäre Tries Eine spezielle Form von Tries sind binäre Tries, die sich auf ein binäres Alphabet mit den Zeichen {0,1} abstützen. Die Daten werden als Bitfolgen interpretiert, d.h. die Verzweigung im Baum erfolgt in Abhängigkeit vom Wert der betrachteten Bitposition 4.5.4 Patricia Bäume (Compressed Tries) Grundidee Teile der Zeichenketten, die für den Vergleich bzw. das Verzweigen irrelevant sind, werden übersprungen. Dies wird erreicht, in dem jeder Knoten die Anzahl der zu überspringenden Bits bzw. Zeichen enthält. So lässt sich die Position in der Zeichenkette bestimmen, die für die Entscheidung über den weiter zu verfolgenden Pfad zu testen ist. Im ursprünglichen Verfahren wurde ein binärer Baum mit Bitfolgen verwendet, es lässt sich jedoch auch ein Alphabet nutzen. Merkmale. - Speicherung aller Schlüssel in den Blättern - innere Knoten speichern, wie viel Zeichen (Bits) beim Test zur Wegeauswahl zu überspringen sind - Vermeidung von Einwegverzweigungen, in dem nur bei einem verbleibenden Schlüssel direkt auf entsprechendes Blatt verwiesen wird. 3 e a Database e u 5 m Datum s Datenbanken Datenbankmodell Datenbanksystem Bewertung - speichereffizient. Gegenüber den einfachen Tries ergibt sich eine deutlich komprimierte Darstellung. Auch der Suchaufwand kann bei sehr langen und wenigen häufigen Worten reduziert werden. - sehr gut geeignet für variable lange Schlüssel und (sehr lange) Binärdarstellungen von Schlüsselwerten 279 Algorithmen und Datenstrukturen - bei jedem Teilschlüssel muß die Testfolge von der Wurzel beginnend ganz ausgeführt werden, bevor über Erfolg oder Misserfolg der Suche entschieden werden kann. - Erfolgreiche und erfolglose Suche endet in einem Blattknoten, z.B. -- Erfolgreiche Suche nach dem Schlüssel Heinz X'10010001000101100110011101011010' -- Erfolglose Suche nach dem Schlüssel Abel X'1000001100001010001011001100' 9 0 25 0 11 H A R A L D H O L G E R 6 H A R T M U T 9 H E I N 6 H U B E R T H E L M U T 2 H E I N R I C H H U B E R H E I N Z n H U B E R T U S Anzahl zu überspringenden Bits Schlüssel Abb.: Präfix- bzw. Radix-Baum: Häufig benutzt man folgende Variante des Patricia-Baums: - Speicherung variable langer Schlüsselteile in den inneren Knoten, sobald sie sich als Präfixe für die Schlüssel des zugehörigen Unterbaums abspalten lassen - erfolglose Suche lässt sich schon oft in einem inneren Knoten abbrechen. Dat 3 a e base u nbank 5 e m n odell m s ystem Abb.: Praefix-Baum 280 Algorithmen und Datenstrukturen 4.5.5 Suffix Tries Ein Suffix Trie ist ein Compressed Trie, der aus allen Suffixes eines String s gebildet 4.5.6 Dateikompression mit dem Huffman-Algorithmus Eine spezielle Form eines Trie ist der optimale Präfix-Baum, der mit Hilfe des Huffman-Algorithmus 157 bestimmt wird. Bsp.: 0 0 1 1 0 e 0 i 1 sp 1 a 0 1 t 0 s 1 nl Abb. Optimaler Präfix-Code Allgemeine Formulierung des Huffman-Algorithmus: Die Anzahl der Zeichen betrage C. Daraus werden C Einzelbäume erstellt, deren Gewicht jeweils die Summe der Häufigkeiten der Blätter darstellt (zu Beginn sind dies nur Einzelknoten). Dann werden (C – 1)-mal jeweils zwei Bäume mit den geringsten Gewichten zu einem neuen Baum zusammen, bis der optimale Code vorliegt. Dateikompression. Der Huffman-Algorithmus kann zur Verdichtung bzw. Kompression von zu speichernden Daten verwendet werden. 157 vgl. 3.2.1.2 281 Algorithmen und Datenstrukturen 5. Graphen und Graphenalgorithmen 5.1 Einführung 5.1.1 Grundlagen Viele Objekte und Vorgänge in verschiedenen Bereichen besitzen den Charakter eines Systems, d.h.: Sie setzen sich aus einer Anzahl von Bestandteilen, Elementen zusammen, die in gewisser Weise in Beziehung stehen. Sollen an einem solchen System Untersuchungen durchgeführt werden, dann ist es oft zweckmäßig, den Gegenstand der Betrachtungen durch ein graphisches Schema (Modell) zu veranschaulichen. Dabei stehen grundsätzlich immer 2 Elemente untereinander in Beziehung, d.h.: Die Theorie des graphischen Modells ist ein Teil der Mengenlehre, die binäre Relationen einer abzählbaren Menge mit sich selbst behandelt. Bsp.: Es ist K = {A, B, C, D} eine endliche Menge. Es ist leicht die Menge aller geordneten Paare von K zu bilden: K × K = {(A,A),(A,B),(A,C),(A,D),(B,A),(B,B),(B,C),(B,D),(C,A),(C,B),(C,C),(C,D),(D,A),(D,B),D,C),(D,D)} Gegenüber der Mengenlehre ist die Graphentheorie nicht autonom. Die Graphentheorie besitzt ein eigenes, sehr weites und spezifisches Vokabular. Sie umfaßt viele Anwendungsungsmöglichkeiten in der Physik, aus dem Fernmeldewesen und dem Operations Research. Im OR sind es vor allem Organisations- bzw. Verkehrs- und Transportprobleme, die mit Hilfe von Graphenalgorithmen untersucht und gelöst werden. Generell dienen Graphenalgorithmen in der Praxis zum Lösen von kombinatorischen Problemen. Dabei geht man folgendermaßen vor: 1. Modelliere das Problem als Graph 2. Formuliere die Zielfunktion als Eigenschaft des Graphen 3. Löse das Problem mit Hilfe eines Graphenalgorithmus Bsp.: Es ist K = {A,B,C,D} ein endliche Menge. Es ist leicht die Menge aller geordneten Paare von K zu bilden: K × K = {(A,A),(A,B),(A,C),(A,D),(B,A),(B,B),(B,C),(B,D),(C,A),(C,B),(C,C),(C,D),(D,A),(D,B),D,C),(D,D)} Die Menge dieser Paare kann auf verschiedene Arten dargestellt werden: 282 Algorithmen und Datenstrukturen 1. Koordinatendarstellung A B C D A B C D Abb.: 2. Darstellung durch Punkte (Kreise) und Kanten (ungerichteter Graph) A B C D Abb.: Eine Kante (A,A) nennt man Schlinge 3. Darstellung durch Punkte (Kreise) und Pfeile (gerichteter Graph) A B D C Abb.: Einen Pfeil (A,A) nennt man eine Schlinge. Zwei Pfeile mit identischem Anfangsund Endknoten nennt man parallel. Analog lassen sich parallele Kanten definieren. Ein Graphen ohne parallele Kanten bzw. Pfeile und ohne Schlingen bezeichnet man als schlichte Graphen. 283 Algorithmen und Datenstrukturen 4. Darstellung durch paarweise geordnete Paare A A B B C C D D Abb Ein bipartiter Graph ist ein Graph, dessen Knoten so in zwei Mengen zerteilt werden können, dass jede Kante je einen Knoten aus beiden Mengen verbindet. Probleme: 1. Herausfinden, ob ein Graph bipartit ist 2. Welches sind die Partitionen Bipartites Matching: Bipartite Graphen dienen häufig zur Lösung Zuordnungsproblemen, z.B. für Männer und Frauen in einem Tanzkurs. Heini von Eva Martin Klaus Maria Pia gematcht Lilo Uwe Abb.: Jeder Teilnehmer im Tanzkurs ist ein Knoten im Graphen zugeordnet, jede Kante beschreibt mögliche Tanzpartner. Drei Paare sind gefunden, aber nicht jeder Knoten hat einen Partner, und es sind keine weiteren Paarungen möglich. 5. Darstellung mit Hilfe einer Matrix A B C D A 1 1 1 1 B 1 1 1 1 C 1 1 1 1 D 1 1 1 1 284 Algorithmen und Datenstrukturen Einige der geordneten Paare aus der Produktmenge K × K sollen eine bestimmte Eigenschaft haben, während die anderen sie nicht besitzen. Eine solche Untermenge von K × K ist : G = {(A,B),(A,D),(B,B),(B,C),(B,D),(C,C),(D,A),(D,B),(D,C),(D,D)} Üblicherweise wird diese Untermenge (Teilgraph) so dargestellt: A B D C Abb.: Betrachtet man hier die Paare z.B. (A,B) bzw. (A,D), so kann man feststellen: Von A erreicht man, den Pfeilen folgend, direkt B oder D. B und D heißt auch die "Inzidenzabbildung" von A und {B,D} das volle Bild von A. Verwendet man das Symbol Γ zur Darstellung des vollen Bilds, dann kann man das vorliegende Beispiel (vgl. Abb.:) so beschreiben: Γ ( A) = ( B, D ) Γ ( B ) = ( B, C, D ) Γ( C ) = C Γ ( D ) = ( A, B, C, D ) Zwei Kanten (Pfeile) werden benachbart oder adjazent genannt, wenn es einen Knoten gibt, der Endknoten einen Kante und Anfangsknoten der anderen Kante ist. Zwei Knoten heißen benachbart oder adjazent, wenn sie durch einen Kante (Pfeil) unmittelbar verbunden sind. Kanten (Pfeile), die denselben Anfangs- und Endknoten haben, heißen parallel. 285 Algorithmen und Datenstrukturen 5.1.2 Definitionen Gegeben ist eine endliche (nicht leere) Menge K 158. Ist G eine Untermenge der Produktmenge K × K , so nennt man ein Element der Menge K einen Knoten von G. Die Elemente der Knotenmenge K können auf dem Papier durch Punkte (Kreise) markiert werden. Ein Element von G selbst ist eine (gerichtete) Kante. Im vorstehenden Bsp 159. sind (A,B), (A,D), (B,B), (B,C), (B,D), (C,C), (D,A), (D,B), (D,C), (D,D) (gerichtete) Kanten. Ein Graph wird durch die Menge seiner Knoten K und die seiner Inzidenzabbildungen beschrieben: G=(K, Γ ) Ein Graph kann aber auch folgendermaßen beschrieben werden: G = (K,E). E ist die Menge der Kanten (gerichtet, ungerichtet, gewichtet). In gewichteten Graphen werden jeder Kante ganze Zahlen (Gewichte, z.B. zur Darstellung von Entfernungen oder Kosten) zugewiesen. Gewichtete gerichtete Graphen werden auch Netzwerke genannt. Falls die Anzahl der Knoten in einem Graphen "n" ist, dann liegt die Anzahl der n ⋅ ( n − 1) im ungerichten Graphen. Ein gerichteter Graph Kanten zwischen 0 und 2 kann bis zu n ⋅ ( n − 1) Pfeile besitzen. Eingangsgrad: Zahl der ankommenden Kanten. 1 3 2 1 2 1 1 2 0 Abb.: Eingangsgrad Ausgangsgrad: Zahl der abgehenden Kanten 2 1 0 1 2 0 1 2 3 Abb.: Ausgangsgrad Bei ungerichteten Graphen ist der Ausgangsgrad gleich dem Eingangsgrad. Man spricht dann nur von Grad. Ein Pfad vom Knoten K1 zum Knoten Kk ist eine Folge von Knoten K1, K2, ... , Kk, wobei (K1,K2), ... ,(Kk-1,Kk) Kanten sind. Die Länge des Pfads ist die Anzahl der Kanten im Pfad. Auch Pfade können gerichtet oder ungerichtet sein. 158 159 Anstatt K schreibt man häufig auch V (vom englischen Wort Vertex abgeleitet) vgl. 5.1.1 286 Algorithmen und Datenstrukturen Kk K1 Abb.: Ein Graph ist zusammenhängend, wenn von jedem Knoten zu jedem anderen Knoten im Graph ein Weg (Pfad) existiert. X1 X5 X2 X4 X3 Abb.: Dieser Graph ist streng zusammenhängend. Man kann sehen, daß es zwischen je 2 Knoten mindestens einen Weg gibt. Dies trifft auf den folgenden Grafen nicht zu: X1 X6 X2 X3 X5 X4 Abb.: Hier gibt es bspw. keinen Weg von X4 nach X1. Ein Graph, der nicht zusammenhängend ist, setzt sich aus zusammenhängenden Komponenten zusammen. Ein Knoten in einem zusammenhängenden Netzwerk heißt Artikulationspunkt, wenn durch sein Entfernen der Graph zerfällt, z.B. 287 Algorithmen und Datenstrukturen Artikulationspunkte sind dunkel eingefärbt. Abb.: Erreichbarkeit: Der Knoten B ist in dem folgenden Graphen erreichbar vom Knoten G, wenn es einen Pfad von G nach B gibt. C E B D F I G A H Abb.: Knoten B ist erreichbar von Knoten G Ein Graph heißt Zyklus, wenn sein erster und letzter Knoten derselbe ist. Abb.: Zyklus (manchmal auch geschlossener Pfad genannt) Ein Zyklus ist ein einfacher Zyklus, wenn jeder Knoten (außer dem ersten und dem letzten) nur einmal vorkommt. Abb.: Einfacher Zyklus (manchmal auch geschlossener Pfad genannt) 288 Algorithmen und Datenstrukturen Ein gerichteter Graph heißt azyklisch, wenn er keine Zyklen enthält. Ein azyklischer Graph kann in Schichten eingeteilt werden (Stratifikation). Bäume sind Graphen, die keine Zyklen enthalten. Graphen, die keine Zyklen enthalten heißen Wald. Zusammenhängender Graphen, die keine Zyklen enthalten, heißen Bäume. Wenn ein gerichteter Graph ein Baum ist und genau einen Knoten mit Eingangsgrad 0 hat, heißt der Baum Wald. Ein spannender Baum (Spannbaum) eines ungerichteten Graphen ist ein Teilgraph des Graphen, und ist ein Baum der alle seine Knoten enthält. Abb. Einen spannenden Baum mit minimaler Summe der Kantenbewegungen bezeichnet man als minimalen spannenden Baum. Zu dem folgenden Graphen 3 4 2 5 4 3 4 4 5 6 gehört der folgende minimale spannende Baum Abb.: Minimaler spannender Baum Eulersche Pfade bzw. Eulerscher Kreis: Ausgangspunkt dieses Problems ist das sog. Königsberger Brückenproblem, das Leonard Euler 1736 gelöst hat. Euler interpretierte dabei die Brücken über den Fluß Pregel in Königsberg als Kanten und Ufer bzw. Inseln als Knoten. 289 Algorithmen und Datenstrukturen neuer Pregel Pregel alter Pregel Abb.: Königsberger Brückenproblem mit Darstellung als Graph Königsberger Brückenproblem: Existiert ein Eulerscher Pfad? Lösung: Da man, wenn man in einen Knoten hineinkommt, auf anderem Weg wieder herauskommen muß, gilt als Bedingung: Der Grad jedes Knoten muß durch 2 teilbar sein. Neuformulierung des Problems: Gibt es einen Zyklus im Graphen, der alle Kanten genau einmal enthält (Eulerkreis). Bedingung für die Existenz eines Eulerkreises: Der Grad jedes Knoten muß durch 2 teilbar sein. Das Königsberger Brückenproblem stellt offenbar keinen Eulerkreis dar. Bekanntes Bsp.: Kann das Häuschen der folgenden Abbildung in einem Strich gezeichnet werden? Abb. Haus des Nikolaus Hamiltonsche Pfade: Gegeben ist eine Landkarte mit Orten und Verbindungen. Gesucht ist ein Rundgang einmal durch jeden Ort. 290 Algorithmen und Datenstrukturen Abb.: Hamiltonscher Kreis Verschärfung: jede Verbindung ist mit Kosten gewichtet. Gesucht ist der billigste Rundgang. Ein Hamiltonscher Pfad ist ein einfacher Zyklus, der jeden Knoten eines Graphen enthält. Ein Algorithmus für das Finden eines Hamiltonschen Graphen ist relativ einfach (modifizierte Tiefensuche) aber sehr aufwendig. Bis heute ist kein Algorithmus bekann, der eine Lösung in polynomialer Zeit findet. 5.1.3 Darstellung in Rechnerprogrammen 1. Der abstrakte Datentyp (ADT) für gewichtete Graphen Ein gewichteter Graph besteht aus Knoten und gewichteten Kanten. Der ADT beschreibt die Operationen, die einem solchen gewichteten Graphen Datenwerte hinzufügen oder löschen. Für jeden Knoten Ki definiert der ADT alle benachbarten Knoten, die mit Ki durch eine Kante E(Ki,Kj) verbunden sind. ADT Graph Daten Sie umfassen eine Menge von Knoten {Ki} und Kanten {Ei}. Eine Kante ist ein Paar (Ki, Kj), das anzeigt: Es gibt eine Verbindung vom Knoten Ki zum Knoten Kj. Verbunden ist mit jeder Kante die Angabe eines Gewichts. Es bestimmt den Aufwand, um entlang der Kante vom Knoten Ki nach dem Knoten Kj zu kommen. Operationen Konstruktor Eingabe: keine Verarbeitung: Erzeugt den Graphen als Menge von Knoten und Kanten Einfuegen_Knoten Eingabe: Ein neuer Knoten Vorbedingung: keine Verarbeitung: Füge den Knoten in die Menge der Knoten ein Ausgabe: keine Nachbedingung: Die Knotenliste nimmt zu Einfügen_Kante Eingabe: Ein Knotenpaar Ki und Kj und ein Gewicht Vorbedingung: Ki und Kj sind Teil der Knotenmenge Verarbeitung: Füge die Kante (Ki,Kj) mit dem gewicht in die Menge der Kanten ein. Ausgabe: keine Nachbedingung: Die Kantenliste nimmt zu Loesche_Knoten Eingabe: Eine Referenz für den Knoten Kl Vorbedingung: Der Eingabewert muß in der Knotenmenge vorliegen 291 Algorithmen und Datenstrukturen Verarbeitung: Lösche den Knoten aus der Knotenliste und lösche alle Kanten der Form (K,Kl) bzw. (Kl,K), die eine Verbindung mit Knoten Kl besitzen Loesche_Kante Eingabe: Ein Knotenpaar Ki und Kj Vorbedingung: Der Eingabewert muß in der Kantenliste vorliegen Verarbeitung: Falls (Ki,Kj) existiert, loesche diese Kante aus der Kantenliste Ausgabe: keine Nachbedingung: Die Kantenmenge wird modifiziert Hole_Nachbarn: Eingabe: Ein Knoten K Vorbedingung: keine Verarbeitung: Bestimme alle Knoten Kn, so daß (K,Kn) eine Kante ist Ausgabe: Liste mit solchen Kanten Nachbedingung: keine Hole_Gewichte Eingabe: Ein Knotenpaar Ki und Kj Vorbedingung: Der Eingabe wert muß zur Knotenmenge gehören Verarbeitung: Beschaffe das Gewicht der Kante (Ki, Kj), falls es existiert Ausgabe: Gib das Gewicht dieser Kante aus (bzw. Null, falls die Kante nicht existiert Nachbedingung: keine 2. Abbildung der Graphen Es gibt zahlreiche Möglichkeiten zur Abbildung von Knoten und Graphen in einem Rechnerprogramm. Eine einfache Abbildung speichert die Knoten in einer sequentiellen Liste. Die Kanten werden in einer Matrix beschrieben (Adjazenzmatrix), in der Zeile i bzw. Spalte j den Knoten Ki und Kj zugeordnet sind. Jeder Eintrag in der Matrix gibt das Gewicht der Kante Eij = (Ki,Kj) oder den Wert 0 an, falls die Kante nicht existiert. In ungewichteten, gerichteten Graphen hat der Eintrag der (booleschen) Wert 0 oder 1, je nachdem, ob die Kante zwischen den Knoten existiert oder nicht, z.B.: 2 A B 3 5 1 4 E C 7 D 0 2 1 0 0 0 0 5 0 0 0 4 0 0 0 0 0 7 0 0 0 3 0 0 0 292 Algorithmen und Datenstrukturen B A C D E 0 1 1 1 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1 0 0 Abb.: In der Darstellungsform „Adjazenzstruktur“ werden für jeden Knoten alle mit ihm verbundenen Knoten in eine Adjazenzliste für diese Knoten aufgelistet. Das läßt sich leicht über verkettete Listen realisieren. In einem gewichteten Graph kann zu jedem Listenelement ein Feld für das Gewicht hinzugefügt werden, z.B.: 2 A B 3 5 1 4 E C 7 Knoten: D Liste der Nachbarn: A B 2 B C 5 C B 4 D C 7 E B 3 C 1 293 Algorithmen und Datenstrukturen B A C D E A B C B A C C A D E E C D Abb.: 3. Lösungsstrategien Für die Lösung der Graphenprobleme stattet man die Algorithmen mit verschiedenen Strategien aus: - Greedy (sukzessive bestimmung der Lösungsvariablen) - Divide and Conquer (Aufteilen, Lösen, Lösungen vereinigen) - Dynamic Programming (Berechne Folgen von Teillösungen) - Enumeration (Erzeuge alle Permutationen und überprüfe sie) - Backtracking (Teillösungen werden systematisch erweitert) - Branch and Bound (Erweitere Teillösungen an der vielversprechenden Stelle) 294 Algorithmen und Datenstrukturen 5.2 Durchlaufen von Graphen Für manche Probleme ist es wichtig, alle Knoten in einem Graphen zu betrachten. So kann man etwa einer in einem Labyrinth eingeschlossenen Person nachfühlen, dass sie sämtliche Kreuzungen von Gängen in Augenschein nehmen will. Die Gänge des Labyrinths sind hier die Kanten des Graphen, und Kreuzungen sind die Knoten. 5.2.1 Tiefensuche (depth-first search) Bei der Tiefensuche bewegt man sich möglichst weit vom Startknoten weg, bevor man die restlichen Knoten besucht. Trifft man auf einen Knoten, der keine unbesuchten Nachbarn hat, so erfolgt "backtracking", d.h. die Suche wird beim Vorgänger fortgesetzt. Dadurch werden alle vom Startknoten erreichbaren Knoten gefunden. Algorithmus: Als Eingabe benötigt der Algorithmus einen Graphen und einen Startknoten. - color[v]: repräsentiert den aktuellen Bearbeitungsstatus weiß = unbesucht/unbearbeitet schwarz = abgearbeitet (v und alle Nachbarn von v wurden besucht). grau = in Bearbeitung (v wurde besucht, kann aber noch unbesuchte Nachbarn haben) - p[v]: Vorgänger (predecessor) von v - b[v]: Beginn der Suche (Einfügen des Knotens in den Stack bzw. Zeitpunkt des rekursiven Aufrufs) - f[v]: Ende der Suche (Löschen des Knotens aus dem Stack bzw. Ende des rekursiven Aufrufs) Die Knoten, die in Bearbeitung sind, werden in einem Stack K (LIFO) verwaltet. for each vertex u ∈ V [G ] − {s} do color[u ] ← WHITE b[u ] ← ∞ f [u ] ← ∞ p[u ] ← NIL time ← 1 color[ s ] ← GRAY PUSH ( K , s ) b[ s ] ← time p[ s] ← NIL while K ≠ 0 do u ← TOP( K ) if ∃v ∈ Adj[u ] : color[v] = WHITE then color[v] ← GRAY PUSH ( K , v) b[v] ← time ← time + 1 else POP( K ) color[u ] ← BLACK f [u ] ← time ← time + 1 Komplexität: Das Initialisieren des Graphen dauert O( | V | ) Zugriffe auf den Stack und die "Arrays" brauchen konstante Zeit (insgesamt O( | V | )), die Adjazenzliste wird 295 Algorithmen und Datenstrukturen genau einmal durchlaufen (O( | E | ). Damit ergibt sich eine Gesamtlaufzeit von O( | V | + | E | ). Bsp.: Tiefensuche in ungerichteten Graphen Anfangsschritt: für alle v ∈ V : color[v] ← WHITE , b[v] ← ∞ , f [v] ← ∞ , p[v] ← NIL Stack u v w x y z 1.Schritt: b[u ] = 1 Stack u v w x y z u 2. Schritt: b[v ] = 2 Stack u v w x y z v u 3. Schritt: b[ w] = 3 Stack u v w w x y v u z 296 Algorithmen und Datenstrukturen 4. Schritt: b[ y ] = 4 Stack u v w y w x y v u z 5. Schritt: b[ x] = 5 Stack x u v w y w x y v u z 6. Schritt: f [ x] = 6 , back edge zu u und v Stack u v w y w x y v u z 7. Schritt: backtracking zu y, f [ y ] = 7 Stack u v w w x 8. Schritt: backtracking zu w, y v u z f [ z] = 8 Stack u v w z w x y v u z 297 Algorithmen und Datenstrukturen 9. Schritt: f [ z] = 9 Stack u v w w x y v u z 10. Schritt: backtracking zu w, f [ w] = 10 Stack u v w x y z v u 11. Schritt: backtracking zu v, f [ w] = 10 Stack u v w x y z u 12. Schritt: backtracking zu w, f [u ] = 10 Stack u v w x y z 298 Algorithmen und Datenstrukturen 5.2.2 Breitensuche (breadth-first search) Die Suche beginnt beim Startknoten, danach werden die Nachbarn der Startknoten besucht, danach die Nachbarn der Nachbarn usw. Dadurch kann die Knotenmenge – entsprechend ihrer minimalen Anzahl von Kanten zum Startknoten – in Level unterteilt werden. In Level 0 befindet sich nur der Startknoten, Level 1 besteht aus allen Nachbarn des Startknoten, usw. Algorithmus. Eingaben sind ein Graph G=(V,E) und ein Startknoten s. Zu jedem Knoten speichert man einige Daten: color[v]: repräsentiert den aktuellen Bearbeitungsstatus weiß = unbearbeitet / unbesucht schwarz = abgearbeitet (v und alle Nachbarn von v wurden besucht) grau = in Bearbeitung (v wurde besucht, kann aber noch unbesuchte Nachbarn haben p[v]: Vorgänger (predecessor) von v d[v]: Distanz zum Startknoten bzgl. der minimalen Kantenzahl Zum Speichern der Knoten, die in Bearbeitung sind, wird eine Warteschlange Q (FIFO) verwendet. u ∈ V [G ] − {s} do color[u ] ← WHITE d [u ] ← ∞ p[u ] ← NIL color[ s ] ← GRAY d [ s] ← 0 p[ s ] ← NIL Q←s while Q ≠ 0 // u ist erstes Element in Q do u ← first[Q ] // Nachbarn von u for v ∈ Adj[u ] do if color[v] ← WHITE then color[v ] ← GRAY d [v] ← d [u ] + 1 p[v] ← u for each vertex ENQUEUE(Q,v) DEQUE(Q) color[v] ← BLACK // füge in Q ein // lösche erstes Element aus Q Komplexität. Das Initialisieren der Arrays dauert insgesamt O( | V | ). Die Operationen auf der Liste (Einfügen und Löschen) und den Arrays brauchen konstante Zeit, insgesamt O( | V | ). Das Durchsuchen der Adjazensliste dauert O( | E | ). Damit ergibt sich eine Gesamtlaufzeit von O( | V | + | E | ). Die Breitensuche konstruiert einen Baum, der die BFS-Baum. Zusammenhangskomponente des Startknotens aufspannt. Der Weg im Baum vom Startknoten (Wurzel) zu den Nachfolgern entspricht dem kürzesten Weg bzgl. der Kantenzahl im Graphen. Die Levelnummer des Knotens entspricht der Höhe im Baum. 299 Algorithmen und Datenstrukturen Bsp.: Breitensuche im ungerichteten Graphen Anfangsschritt: für alle v ∈ V : color[v] ← WHITE , d [v ] = ∞ , p[v] ← NIL r s t u v w x y 1. Schritt: Startknoten wird grau markiert, Q = (s), d[s] = 0 r s t u v w x y 2. Schritt: Q = (w,r), Level 0 abgearbeitet r s t u v w x y r s t u v w x y t u 3. Schritt: Q = (r,t,x) 4. Schritt: Q = (t,x,v), Level 1 abgearbeitet r s v w x y 300 Algorithmen und Datenstrukturen 5. Schritt: Q = (x,v,u) r s v w t u x y 6. Schritt: Q = (v,u,y) r s v w t u x y 7. Schritt: Q = (u,y) r s v w r s v w t u x y 8. Schritt: Q = (y) t u x y 9. Schritt: Q = (), Level 3 abgearbeitet r s t u v w 1 0 2 3 r s t u v w x y 10. Schritt: y x 301 Algorithmen und Datenstrukturen 2 1 2 3 5.2.3 Implementierung In der Klasse Graph sind Tiefensuche (Methode traverseDFS) und Breitensuche (traverseBFS) implementiert 160. import java.util.*; /** Graphrepräsentation. */ /** Repräsentiert einen Knoten im Graphen. */ class Vertex { Object key = null; // Knotenbezeichner LinkedList edges = null; // Liste ausgehender Kanten /** Konstruktor */ public Vertex(Object key) { this.key = key; edges = new LinkedList(); } /** Ueberschreibe Object.equals-Methode */ public boolean equals(Object obj) { if (obj == null) return false; if (obj instanceof Vertex) return key.equals(((Vertex) obj).key); else return key.equals(obj); } /** Ueberschreibe Object.hashCode-Methode */ public int hashCode() { return key.hashCode(); } } /** Repraesentiert eine Kante im Graphen. */ class Edge { Vertex dest = null; // Kantenzielknoten int weight = 0; // Kantengewicht /** Konstruktor */ public Edge(Vertex dest, int weight) { this.dest = dest; this.weight=weight; } } class GraphException extends RuntimeException { public GraphException( String name ) { super( name ); } } public class Graph { protected Hashtable vertices = null; // enthaelt alle Knoten des Graphen /** Konstruktor */ public Graph() { vertices = new Hashtable(); } /** Fuegt einen Knoten in den Graphen ein. */ public void addVertex(Object key) { if (! vertices.containsKey(key)) // throw new GraphException("Knoten existiert bereits!"); vertices.put(key, new Vertex(key)); } 160 vgl. pr52220 302 Algorithmen und Datenstrukturen /** Fuegt eine Kante in den Graphen ein. */ public void addEdge(Object src, Object dest, int weight) { Vertex vsrc = (Vertex) vertices.get(src); Vertex vdest = (Vertex) vertices.get(dest); if (vsrc == null) throw new GraphException("Ausgangsknoten existiert nicht!"); if (vdest == null) throw new GraphException("Zielknoten existiert nicht!"); vsrc.edges.add(new Edge(vdest, weight)); } /** Liefert einen Iterator ueber alle Knoten. */ public Iterator getVertices() { return vertices.values().iterator(); } /** Liefert den zum Knotenbezeichner gehoerigen Knoten. */ public Vertex getVertex(Object key) { return (Vertex) vertices.get(key); } /** Liefert die Liste aller erreichbaren Knoten in Breitendurchlauf. */ public List traverseBFS(Object root) { LinkedList list = new LinkedList(); Hashtable d = new Hashtable(); Hashtable pred = new Hashtable(); Hashtable color = new Hashtable(); Integer gray = new Integer(1); Integer black = new Integer(2); Queue q = new Queue(); Vertex v, u = null; Iterator eIter = null; //v = (Vertex)vertices.get(root); color.put(root, gray); d.put(root, new Integer(0)); q.enqueue(root); while (! q.isEmpty()) { v = (Vertex) vertices.get(((Vertex)q.firstEl()).key); eIter = v.edges.iterator(); while(eIter.hasNext()) { u = ((Edge)eIter.next()).dest; // System.out.println(u.key.toString()); if (color.get(u) == null) { color.put(u, gray); d.put(u, new Integer(((Integer)d.get(v)).intValue() + 1)); pred.put(u, v); q.enqueue(u); } } q.dequeue(); list.add(v); color.put(v, black); } return list; } /** Liefert die Liste aller erreichbaren Knoten im Tiefendurchlauf. */ public List traverseDFS(Object root) { // Loesungsvorschlag: H. Auer LinkedList list = new LinkedList(); // Hashtable d = new Hashtable(); // Hashtable pred = new Hashtable(); Hashtable color = new Hashtable(); Integer gray = new Integer(1); 303 Algorithmen und Datenstrukturen Integer black = new Integer(2); Stack s = new Stack(); Vertex v, u = null; Iterator eIter = null; //v = (Vertex)vertices.get(root); color.put(root, gray); // d.put(root, new Integer(0)); s.push(root); while (! s.empty()) { v = (Vertex) vertices.get(((Vertex)s.peek()).key); eIter = v.edges.iterator(); u = null; Vertex w; while(eIter.hasNext()) { w = ((Edge)eIter.next()).dest; // System.out.println(u.key.toString()); if (color.get(w) == null) { u = w; break; } } if (u != null) { color.put(u, gray); s.push(u); } else { v = (Vertex) s.pop(); list.add(v); color.put(v, black); } } return list; } } Anstatt einen Stapel explizit in die Tiefensuche einzubeziehen, kann man Tiefensuche rekursiv so formulieren: LinkedList liste = new LinkedList(); Hashtable color = new Hashtable(); Integer gray = new Integer(1); Integer black = new Integer(2); // Iterator eIter = null; public List traverseDFSrek(Object root) { // LinkedList list = new LinkedList(); // Hashtable d = new Hashtable(); // Hashtable pred = new Hashtable(); // Hashtable color = new Hashtable(); // Integer gray = new Integer(1); // Integer black = new Integer(2); // Stack s = new Stack(); Vertex v = (Vertex) root; Vertex u = null; Iterator eIter = null; //v = (Vertex)vertices.get(root); color.put(root, gray); // d.put(root, new Integer(0)); // s.push(root); // while (! s.empty()) // { // v = (Vertex) vertices.get(((Vertex)s.pop()).key); // liste.add(v); // color.put(v,black); eIter = v.edges.iterator(); while(eIter.hasNext()) { u = ((Edge)eIter.next()).dest; // System.out.println(u.key.toString()); if (color.get(u) == null) { color.put(u, gray); traverseDFSrek(u); 304 Algorithmen und Datenstrukturen } } liste.add(v); // s.pop(); // list.add(v); color.put(v, black); //} return liste; } Abb.: Durchläufe zur Breiten- bzw. Tiefensuche 305 Algorithmen und Datenstrukturen 5.3 Topologischer Sort Sortieren bedeutet Herstellung einer totalen (vollständigen) Ordnung. Es gibt auch Prozesse zur Herstellung von teilweisen Ordnungen 161, d.h.: Es gibt eine Ordnung für einige Paare dieser Elemente, aber nicht für alle. In Graphen für die Netzplantechnik ist die Feststellung partieller Ordnungen zur Berechnung der kürzesten (und längsten) Wege erforderlich. Bsp.: Die folgende Darstellung zeigt einen Netzplan zur Ermittlung des kritischen Wegs. Die einzelnen Knoten des Graphen sind Anfangs- und Endereignispunkte der Tätigkeiten, die an den Kanten angegeben sind. Die Kanten (Pfeile) beschreiben die Vorgangsdauer und sind Abbildungen binärer Relationen. Zwischen den Knoten liegt eine partielle Ordnungsrelation. Bestelle A 50 Tage Baue B Teste B 4 1 20 Tage Korrigiere Fehler 2 25 Tage 15 Tage 3 Handbucherstellung 60 Tage Abb. : Ein Graph der Netzplantechnik Zur Berechnung des kürzesten Wegs sind folgende Teilfolgen, die partiell geordnet sind, nötig: 1 -> 3: 50 Tage 1->4->2->3: 60 Tage 1->4->3: 80 Tage (kürzester Weg) Eindeutig ist das Bestimmen der topologischen Folgen nicht. Zu dem folgenden Graphen 2 1 4 3 kann es mehrere topologische Folgen geben.Zwei dieser topologischen Folgen sind 161 vgl. 1.2.2.2 306 Algorithmen und Datenstrukturen 1 2 1 3 3 4 2 4 Abb.: Bezugspunkt zur Ableitung eines Algorithmus für den topologischen Sort ist ein gerichteter, azyklischer Graph, z.B. 0 1 1 2 2 3 1 3 4 5 3 2 6 7 Über der Knotenidentifikationen ist zusätzlich die Anzahl der Vorgänger vermerkt. Dieser Zähler wird in die Knotenbeschreibung aufgenommen. Der Zähler soll festhalten, wie viele unmittelbare Vorgänger der Knoten hat. Hat ein Knoten keine Vorgänger, dann wird der Zähler auf 0 gesetzt. Damit kann der Algorithmus durch folgende Pseudocode-Darstellung beschrieben werden. void topsort() { Queue q; int zaehler = 0; Vertex v, w; q = new Queue(); for each vertex v if (v.indegree 162 == 0) q = new Queue(); while (!q.isEmpty()) { v = q.dequeue(); zaehler++; for each w adjacent to v if (--w.indegree == 0) q.enqueue(w); } if (zaehler != anzahlKnoten) System.out.println(“Fehler: Zyklus gefunden”); } 162 indegree ist der Zähler für die jeweilige Anzahl von Vorgängerknoten 307 Algorithmen und Datenstrukturen Zur Bestimmung der gewünschten topologischen Folge wird mit den Knotenpunktnummern begonnen, deren Zähler den Wert 0 enthalten. Sie verfügen über keinen Vorgänger und erscheinen in der topologischen Folge an erster Stelle. Schreibtischtest. Die folgende Tabelle soll anhand des folgenden Graphen 1 2 3 4 5 6 7 die Veränderung des Zählers für unmittelbare Vorgänger zeigen und über die Knotenidentifikationen das Ein- bzw. Ausgliedern aus der Schlange (Queue) q. Vertex 1 2 3 4 5 6 7 Enqueue Dequeue 1 0 1 2 3 1 3 2 1 1 2 0 0 1 2 1 3 2 2 2 3 0 0 1 1 0 3 2 5 5 4 0 0 1 0 0 3 1 4 4 5 0 0 0 0 0 2 0 3,7 3 Komplexität. 308 6 0 0 0 0 0 1 0 7 7 0 0 0 0 0 0 0 6 6 Algorithmen und Datenstrukturen 5.4 Transitive Hülle Welche Knoten sind von einem gegeben Knoten aus erreichbar? Gibt es Knoten, von denen aus alle anderen Knoten erreicht werden können? Die Bestimmung der transitiven Hülle ermöglicht die Beantwortung solcher Fragen. S. Warshall hat 1962 einen Algorithmus entwickelt, der die Berechnung der transitiven Hülle über seine Adjazenzmatrix ermöglicht und nach folgenden Regeln arbeitet: Falls ein Weg existiert, um von einem Knoten x nach einem Knoten y zu gelangen, und ein Weg, um vom Knoten y nach z zu gelangen, dann existiert auch ein Weg, um vom Knoten x nach dem Knoten z zu gelangen. Bsp.: Der fogende Graph enthält gestrichelte Kanten, die die Erreichbarkeit markieren A B C D E Die zu diesem Graphen errechnete transitive Hülle beschreibt die folgende Erreichbarkeitsmatrix: 1 0 0 1 0 1 1 0 1 0 1 1 1 1 1 0 0 0 1 0 1 1 0 1 1 309 Algorithmen und Datenstrukturen 5.5 Kürzeste Wege 5.5.1 Der Algorithmus von Dijkstra Der Algorithmus von Dijkstra 163 (aus dem Jahre 1959) löst folgendes Problem: Ausgehend von einem Startknoten (z.B. a) werden zunächst für alle Knoten die direkten Knoten eingetragen. Nun wird der billigste noch nicht besuchte Knoten gewählt und getestet, ob von diesem aus andere Knoten günstiger erreichbar sind. Diese Änderungen werden gespeichert und der Knoten als besucht markiert. Das Vorgehen wird solange wiederholt, bis alle Knoten besucht wurden. Die Komplexität des Verfahrens von Dijkstra beträgt O( | V 2 | ). Implementierung 164: public static final int INFINITY = Integer.MAX_VALUE; public int [] dijkstra(int [][] a, int start) { if (a == null || a.length == 0) return null; // Matrix ist leer boolean visited[] = new boolean[a.length]; // Knoten besucht int [] costs = new int[a.length]; // Kosten start -> i int i, w = 0, j, billigsteKosten, n = a.length; for (i = 0; i < n; i++) visited[i] = false; visited[start] = true; // Kosten setzen im Rahmen der Initialisierung for (i = 0; i < n; i++) costs[i] = (a[start][i] > 0) ? a[start][i] : INFINITY; costs[start] = 0; // Start kostenlos for (i = 0; i < n; i++) { // Suche nicht besuchte Knoten w mit costs[w] minimal billigsteKosten = INFINITY; // maximale Kosten for (j = 0;j < n; j++) { if (!visited[j] && costs[j] < billigsteKosten) { w = j; billigsteKosten = costs[w]; } } visited[w] = true; // markiere w als besucht for (j = 0; j < n; j++) { if (a[w][j] == 0) continue; costs[j] = java.lang.Math.min(costs[j],costs[w] + a[w][j]); } } return costs; } 163 164 vgl. 2.2.11.3 pr52221 310 Algorithmen und Datenstrukturen Testbeispiel und Test: [0] [1] 3 a b 2 [2] 6 c [3] 4 1 5 d [4] 5 2 1 e [5] f 4 Abb.: Graph für den Test des Dijkstra-Algorithmus Der Test führt zu folgendem Programmablauf: Abb.: Lösungsschritte beim Test Nachteile. Der Algorithmus von Dijkstra hat zwei Nachteile: Es wurden nur die kürzesten Verbindungen von einem ausgezeichneten Startknoten zu einem anderen Knoten bestimmt. Die Gewichte aller Kanten müssen positiv sein 311 Algorithmen und Datenstrukturen 5.5.2 Der Algorithmus von Floyd Der Algorithmus von Floyd berechnet die kürzesten Verbindungen von allen Knoten zu allen Knoten Zugrundeliegende Idee: Es werden alle direkten Verbindungen zweier Knoten als die "billigste" Veränderung der Beiden Knoten verwendet. Die billigste Verbindung ist entweder die direkte Verbindung oder aber zwei Wege über einen Mittelknoten. Die Komplexität des Verfahrens von Floyd beträgt O( | V 3 | ). Implementierung 165: public static final int NO_EDGE = 0; public int [][] floyd(int [][] a, int start) { if (a == null || a.length == 0) return null; // Matrix ist leer int i, j, x, n = a.length; // i = Start, j = Ende, x = Zwischenknoten // Anlegen einer neuen Adjazenzmatrix int [][] c = new int[n][n]; // Kopiere alle Werte aus der Matrix: Am Anfang ist die // direkte Verbindung die einzige und daher auch die // billigste for (i = 0; i < n; i++) for (j = 0; j < n; j++) { c[i][j] = a[i][j]; // direkte Kanten kopieren } // Suche fuer Knoten x nach Wegen ueber x, d.h. i -> x, x -> j for (x = 0; x < n; x++) for (i = 0; i < n; i++) if (c[i][x] != NO_EDGE) // gibt es einen Weg i -> x for (j = 0; j < n; j++) if (c[x][j] != NO_EDGE) if (c[i][j] == NO_EDGE // noch kein Weg i -> j || (c[i][x] + c[x][j] < c[i][j])) // i->x->j billiger { if (i == j) continue; c[i][j] = c[i][x] + c[x][j]; } return c; } Der Test dieses Algorithmus führt zu folgendem Resultat: 165 pr52221 312 Algorithmen und Datenstrukturen 5.6 Minimale Spannbäume Anwendung. Minimale spannende Bäume sind z.B. für folgende Fragestellung interessant: "Finde die billigste Möglichkeit alle Punkte zu verbinden". Diese Frage stellt sich bspw. für elektrische Schaltungen, Flugrouten und Autostrecken. Problemstellung. Zu einem zusammenhängenden Graphen soll ein Spannbaum (aufspannender Baum) mit minimalem Kantengewicht (minimale Gesamtlänge) bestimmt werden. Der minimale Spannbaum muß nicht eindeutig sein, zu jedem gewichteten Graphen gibt es aber mindestens einen minimalen spannenden Baum. 5.6.1 Der Algorithmus von Prim Das einfachste Verfahren zur Erzeugung eines minimalen spannenden Baums stammt von Prim aus dem Jahre 1952. In diesem Verfahren wird zu dem bereits vorhandenen Teilgraph immer die billigste Kante hinzugefügt, die den Teilgraph mit einem bisher noch nicht besuchten Knoten verbindet. Aufgabe. Berechne einen spannenden Baum mit minimalen Kosten (minimum spanning tree). Lösungsbeschreibung. Der folgende Graph 2 k2 k1 4 1 3 10 2 7 k4 k3 5 8 k5 4 6 k7 k6 1 313 Algorithmen und Datenstrukturen besitzt folgenden minimale Spannbaum: 2 k2 k1 1 2 k4 k3 k5 4 6 k7 k6 1 Abb.: Die Anzahl der Kanten in einem minimal spannenden Baum ist |V| - 1 (Anzahl der Knoten – 1). Der minimal spannende Baum ist - ein Baum, der keine Zyklen besitzt. - spannend, da er jeden Knoten abdeckt. - ein Minimum. Der Algorithmus von Prim arbeitet stufenweise. Auf jeder Stufe wird ein Knoten ausgewählt. Die Kanten auf seine nachfolgenden Knoten werden dann untersucht. Die Untersuchung folgt nach den Vorschriften des Dijkstra-Algorithmus. Es gibt nur eine Ausnahme hinsichtlich der Ermittlung der Distanz: d w = min(d v , c vw ) Die Ausgangssituation zeigt folgende Tabelle: k k1 k2 k3 k4 k5 k6 k7 bekannt false false false false false false false dv 0 ∞ ∞ ∞ ∞ ∞ ∞ pv null null null null null null null Abb.: Ausgangssituation „k1“ wird ausgewählt, „k2, k3, k4 sind zu k1 benachbart“. Das führt zur folgenden Tabelle: k k1 k2 k3 k4 k5 k6 k7 bekannt true false false false false false false dv 0 2 4 1 ∞ ∞ ∞ pv null k1 k1 k1 null null null Abb.: Die Tabelle im Zustand „k1 ist bekannt“ Der nächste Knoten, der ausgewählt wird ist k4. Jeder Knoten ist zu k4 benachbart. Ausgenommen ist k1, da dieser Knoten „bekannt“ ist. k2 bleibt unverändert, denn die 314 Algorithmen und Datenstrukturen „Kosten“ von k4 nach k2 sind 3, bei k2 ist 2 eingetragen. Der Rest wird, wie die folgende Tabelle zeigt, verändert: k k1 k2 k3 k4 k5 k6 k7 bekannt true false false true false false false dv 0 2 2 1 7 8 4 pv null k1 k4 k1 k4 k4 k4 Abb.: Die Tabelle im Zustand „k4 ist bekannt“ Der nächste Knoten, der ausgewählt wird, ist k2. Das zeigt keine Auswirkungen. Dann wird k3 gewählt. Das bewirkt eine Veränderung der Distanz zu k6. k k1 k2 k3 k4 k5 k6 k7 bekannt true true true true false false false dv 0 2 2 1 7 5 4 pv null k1 k4 k1 k4 k3 k4 Abb.: Tabelle mit Zustand „k2 ist bekannt“ und (anschließend) mit dem Zustand „k3 ist bekannt“ Es folgt die Wahl des Knoten k7, was die Ausrichtung von k6 und k5 bewirkt: k k1 k2 k3 k4 k5 k6 k7 Bekannt true true true true false false true dv 0 2 2 1 6 1 4 pv null k1 k4 k1 k7 k7 k4 Abb.: Tabelle mit Zustand „k7 ist bekannt“ Jetzt werden noch k6 und dann k5 bestimmt. Die Tabelle nimmt danach folgende Gestalt an: k k1 k2 k3 k4 k5 k6 k7 Bekannt true true true true true true true dv 0 2 2 1 6 1 4 pv null k1 k4 k1 k7 k7 k4 Abb.: Tabelle mit Zustand „k6 ist bekannt“ und (anschließend) „k5 ist bekannt“ Die Tabelle zeigt, daß folgende Kanten den minimal spannenden Baum bilden: (k2,k1),k3,k4)(k4,k1),(k5,k7),(k6,k7),(k7,k4) 315 Algorithmen und Datenstrukturen Der Algorithmus von Prim zeigt weitgehende Übereinstimmung mit dem Algorithmus von Dijkstra 166. Komplexität: Die Laufzeit ist O(|V|2) Implementierung. MinimalSpanningTree.java 167 Abb. 5.6.2 Der Algorithmus von Kruskal Beschreibung des Algorithmus. 1. Markiere alle Knoten als nicht besucht. 2. Erstelle eine neue Adjazenzmatrix, in der die tatsächlich verwendeten Kanten eingetragen werden. Zu Beginn sind alle Elemente 0. 3. Bestimme die billigste Kante von einem Knote i zu einem Knoten j, die entweder zwei bisher nicht erreichte Knoten verbindet, einen nicht nicht erreichten mit einem erreichten oder zwei bisher unverknüpfte Teilgraphen verbindet. Falls beide Knoten bereits erreicht wurden, kann diese Kante ignoriert werden, da durch sie ein Zyklus entstehen würde. 4. Markiere i und j als erreicht und setze minimalTree[i][j]= g, wobei g das Gewicht der Kante (i,j) ist. 5. Fahre mit Schritt 3 fort, bis alle Knoten erreicht sind 166 167 vgl. 2.2.11.2 vgl. pr53330 316 Algorithmen und Datenstrukturen Bsp.: Gegeben ist 2 k2 k1 4 1 3 10 2 7 k4 k3 5 8 k5 4 6 k7 k6 1 Bestimme den minimale spannenden Baum nach dem Algorithmus von Kruskal: 1. Schritt k2 k1 1 k4 k3 k5 k7 k6 2. Schritt k2 k1 1 k4 k3 k5 k7 k6 1 3. Schritt 2 k2 k1 1 k4 k3 k5 k7 k6 1 317 Algorithmen und Datenstrukturen 4. Schritt 2 k2 k1 1 2 k4 k3 k5 k7 k6 1 5. Schritt 2 k2 k1 1 2 k4 k3 k5 4 k7 k6 1 6. Schritt 2 k2 k1 1 2 k4 k3 k5 4 6 k7 k6 1 Abb. Lösungsschritte zum Demonstrationsbeispiel Prinzip. Auswahl der Kanten in der Reihenfolge kleinster Gewichte mit Aufnahme einer Kante, falls sie nicht einen Zyklus verursacht. Implementierung. MinimalSpanningTree.java 318