5. Compiler Gliederung 1. Struktur eines Compilers 2. Syntaxanalyse durch rekursiven Abstieg 3. Ausnahmebehandlung 4. Arrays und Strings 6. Sortieren und Suchen 1. Binäre Bäume 2. B-Bäume und Tries 3. Sortieren in Vektoren 4. Streuspeicherung 7. Graphen 1. Darstellung und Topologisches Sortieren 2. Kürzeste Wege 3. Fluß- und Zuordnungsprobleme
Überblick Arrays und Strings Wie können mehrere Elemente eines gleichen Datentyps in einem Bezeichner zusammengefasst werden? Wie werden Zeichenketten in Java unterstützt?
Besonderheiten von Arrays und Strings Arrays und Strings sind in Java Objekte Sowohl bei Strings als auch bei Arrays kennt der Compiler Literale, die einen expliziten Aufruf des new -Operators überflüssig machen Arrays sind "klassenlose" Objekte Arrays besitzen aber keine explizite Klassendefinition Arrays haben sie eine öffentliche Instanzvariable length und werden vom Laufzeitsystem wie normale Objekte behandelt.
Besonderheiten von Objekten Zuweisung: kopiert den Verweis, nicht das Objekt. Objekte kopieren: Methode clone() verwenden Test auf Gleichheit: testet auf Gleichheit der Referenzen, also auf Gleichheit des Objekts, nicht auf inhaltliche Gleichheit. Inhaltliche Gleichheit überprüfen: Methode equals() verwenden Ein besonderes Objekt null bezeichnet das leere Objekt null ist die Standard-Initialisierung von Objekten
Arrays (1) Fassen mehrere Elemente eines gleichen Datentyps in einem Bezeichner zusammen Deklaration von Arrays <Array-Type> ::= <Type> [] Beispiele int[] arr; String[] stringarray; Array-Objekte erzeugen <Array-Creation> ::= new <Type> [<Size>] Beispiele int[] arr = new int[15] String[] stringarray = new String[9];
int[] pin = {2, 5, 1, 7}; äquivalent zu: int[] pin = new int[4]; pin[0] = 2; pin[1] = 5; pin[2] = 1; pin[3] = 1; Initialisieren von Arrays String[] raubtier = { loewe, tiger, hai }; äquivalent zu: String[] raubtier = new String[3]; raubtier[0] = loewe ; raubtier[1] = tiger ; raubtier[2] = hai ;
Arrays (2) Typische Operationen auf Arrays Anzahl der Elemente abfragen Selektion eines Elementes aus einem Array Zugriff auf einzelnes Element über eckige Klammern und ganzzahligen, positiven Indexausdruck z.b. a[0], a[1], a[3] Der Index eines Arrays kann durch einen Ausdruck berechnet werden int i=5; a[i+1] = a[i]+a[i-1] In Java ist der erste Index immer 0, der letzte immer <Size> - 1 Wird ein falscher Index angegeben, tritt eine Ausnahme (ArrayIndexOutOfBoundsException) auf Jedes Array speichert automatisch seine Größe, Zugriff über <Arrayname>.length
Semantik der Zuweisung int[] a=null; b[] = { 4, 5, 6 }; a b Ẋ 4 5 6 a = b; a b 4 5 6 8
Arrays (3) Prüfen, ob Element in Array enthalten ist mit for-schleife <For-Schleife> ::= for(<init>; <Weitertest>; <update>) { <Anweisung> } wiederholt eine bestimmte Anzahl von Schritten mit einem Zähler. Der Zähler wird häufig lokal deklariert Schrittweite und Richtung kann angegeben werden for(i = START; i > ENDEWERT; i = i - SCHRITT)... for(int i = 0; i < 10; i++) { System.out.println( "i: "+i); } Lokale Schleifenvariable
Arrays (4) Prüfen ob ein Element im Array enthalten ist Deklaration eines Arrays mit 5 Elementen Int[] a = new int[42];... boolean contains(int wert) { boolean value = false; for (int i = 0; i < a.length; i++) { if (a[i] == wert) { value = true; } } return value; } Bildung eines Arrays für 42 ganze Zahlen Größe des Arrays
Mehrdimensionale Arrays Mehrdimensionale Arrays sind Arrays, deren Elemente Arrays sind. Deklaration: int[][] tabelle; Anlegen: tabelle = new int[3][2]; tabelle = new int[3][]; tabelle[0] = new int[2];
Mehrdimensionale Arrays (2) statische Initialisierung: int multiarray[][] = { { 1 }, {1, 2, 1}, {1, 3, 3, 1 }, {1, 4, 6, 4, 1}};
Strings (1) Strings Können über ein Literal definiert werden. Überladener Operator: Konkatenation über + möglich Strings sind Zeichenketten: Interne Datenspeicherung als char[] Typische Operationen auf Strings Länge abfragen Testen auf Gleichheit Aneinanderhängen Selektion des i-ten Zeichens Teilstrings extrahieren
Strings: Besonderheiten Methoden können auch direkt bei einem String-Literal ausgeführt werden System.out.println( Hello Students.length() ); Sonderzeichen sind über Escape Sequenzen zu notieren System.out.println( \n ); // gib einen Zeilenvorschub aus
Strings (2)... void StringTest(){ String s1; s1 = "Auf der Mauer"; s1 += ", auf der Lauer"; s1 += ", sitzt \'ne kleine Wanze"; System.out.println(s1); for (int i = 1; i <= 5; ++i) { s1 = s1.substring(0,s1.length()-1); System.out.println(s1); } }... 15
5. Compiler Gliederung 1. Struktur eines Compilers 2. Syntaxanalyse durch rekursiven Abstieg 3. Ausnahmebehandlung 4. Referenztypen 6. Sortieren und Suchen 1. Binäre Bäume 2. B-Bäume und Tries 3. Sortieren in Vektoren 4. Streuspeicherung 7. Graphen 1. Darstellung und Topologisches Sortieren 2. Kürzeste Wege 3. Fluß- und Zuordnungsprobleme
Suchen in sortierten Folgen Folgen als Arrays repräsentiert Beispiel: Finden eines Eintrags im Telefonbuch Annahme im Folgenden: Wir betrachten nur den für die Suche relevanten Teil des Eintrags (= Schlüssel) Für Schlüssel sind die Vergleichsoperationen (=,<,>) definiert Die Schlüssel sind ganze Zahlen Beim Telefonbuch: Name des Teilnehmers 17
Sequenzielle Suche Einfachste Variante des Suchens: Folge sequenziell durchlaufen In jedem Schritt wird das aktuelle Element mit dem Suchschlüssel verglichen Eingabe: Folge F der Länge n, Suchschlüssel k Ausgabe: Position p des ersten Elements aus F, das gleich k ist, sonst NO_KEY Algorithmus (Pseudocode-Notation) for i:=1 to n do if F[i]=k then return i fi od; return NO_KEY 18
Aufwand Sequenzielle Suche (2) Kriterium für die Beurteilung von Suchverfahren Hier: Anzahl der notwendigen Vergleichsoperationen In Abhängigkeit der Länge n der sortierten Folge 19
Aufwand (Übersicht) Sequenzielle Suche (3) Anzahl der Vergleiche Bester Fall 1 Schlechtester Fall n Durchschnitt (erfolgreiche Suche) Durchschnitt (erfolglose Suche) n/2 n 20
Sequenzielle Suche (4) Algorithmus (Java-Implementierung)... int NO_KEY = -1; int SeqSuche (int[] array, int key) { for (int i=0; i<array.length; i++) if (array[i] == key) return i; return NO_KEY; }... 21
Binäre Suche Motivation: Sequentielle Suche ist aufwendig So schlägt man im Telefonbuch nach: 1. Schlage an zufälliger Stelle auf (in etwa die Mitte) 2. Wenn der Eintrag nicht auf dieser Seite, dann prüfe, ob der gesuchte Eintrag in der ersten oder in der zweiten Hälfte liegt und fahre für diese mit 1. fort. Ansonsten: Fertig. Beobachtung: Der zu durchsuchende Bereich wird immer halbiert (Daher die Bezeichnung binäres Suchen) 22
Binäre Suche (2) Eingabe: Folge F der Länge n, Suchschlüssel k Ausgabe: Position p des ersten Elementes aus F, das gleich k ist, sonst NO_KEY Algorithmus (Pseudocode-Notation) u:=1, o:=n; while u<=o do m:=(u+o)/2; if F[m]=k then return m else if k<f[m] then o:=m else u:=m fi od; return NO_KEY 23
Binäre Suche (3) Suchen nach dem Schlüssel 8 1 2 3 4 5 6 7 8 9 10 0 1 2 4 5 8 9 12 13 18 u m o 0 1 2 4 5 8 9 12 13 18 u m o 0 1 2 4 5 8 9 12 13 18 u m o 24
Aufwand der binären Suche (1) Günstigster Fall: Das gesuchte Element ist in der Mitte der Folge und wird nach dem 1. Schritt gefunden Sonst Nach dem 1. Aufteilen der Folge müssen noch n/2 Elemente durchsucht werden Nach dem 2. Aufteilen der Folge müssen noch n/4 durchsucht werden Nach dem 3. Aufteilen der Folge müssen noch n/8 Elemente durchsucht werden... Nach dem i. ten Aufteilen der Folge müssen noch n/2 i Elemente durchsucht werden 25
Aufwand der binären Suche (2) Aufwand (ld ist der Logarithmus zur Basis 2) Anzahl der Vergleiche Bester Fall Schlechtester Fall Durchschnitt (erfolgreiche Suche) Durchschnitt (erfolglose Suche) 1 ld n ld n ld n 26
Algorithmus (Java-Implementierung)... int NO_KEY = -1; Binäre Suche (5) int BinSuche (int[] array, int key) { int u=0, o=array.length 1; while (u<=o) { int m = (u+o) / 2; if (array[m] == key) return m; else if (array[m] > key) o = m; else u = m; } return NO_KEY; }... } 27
Vergleich sequentielle vs. Binäre Suche (6) Anzahl der durchgeführten Vergleiche für unterschiedliche Eingaben Verfahren 10 10 2 10 3 10 4 sequentiell ~5 ~50 ~500 ~5000 binär ~3.3 ~6.6 ~9.9 ~13.3 28
Klassen von Sortierverfahren Sortieren Interne Verfahren: Sortierung von Datensätzen (z.b. Arrays, Listen), die im Hauptspeicher gehalten werden können Externe Verfahren: Sortierung von Massendaten, die auf externen Speichermedien gehalten werden Typisch für Datenbanken 29
Sortieren durch Einfügen (1) Als InsertionSort bekannt Umsetzung des typisch menschlichen Vorgehens beim Sortieren eines Stapels von Karten Starte mit der ersten Karte einen neuen Stapel Nimm jeweils die nächste Karte des Originalstapels und füge diese an der richtigen Stelle in den neuen Stapel ein 30
Sortieren durch Einfügen (2) 1. Durchlauf 5 1 8 3 9 2 2. Durchlauf 1 5 8 3 9 2 3. Durchlauf 1 5 8 3 9 2 4. Durchlauf 1 3 5 8 9 2 5. Durchlauf 1 3 5 8 9 2 6. Durchlauf 1 2 3 5 8 9 31
Sortieren durch Einfügen (2) Algorithmus (Java-Implementierung)... void insertionsort (int[] array) { for (int i=1;i<array.lengh;i++) { int j=i; int m = array[i]; // für alle Elemente links vom Marker-Feld while (j>0 && array[j-1]>m { // verschiebe alle größeren Elemente nach hinten array[j] = array[j-1]; j--; } // setze m auf das freie Feld array[j] = m; } }... 32
Vorgehen Sortieren durch Selektion (1) Wähle das größte Element der Folge und bringe es ans Ende. Verfahre weiter so, wobei die Folge in jedem Schritt um eine Position verkürzt wird 33
Sortieren durch Selektion (2) 1. Durchlauf 5 1 8 3 9 2 2. Durchlauf 5 1 8 3 2 9 3. Durchlauf 5 1 2 3 8 9 4. Durchlauf 3 1 2 5 8 9 5. Durchlauf 2 1 3 5 8 9 6. Durchlauf 1 2 3 5 8 9 34
Sortieren durch Selektion (3) Algorithmus (Java-Implementierung)... void swap (int[] array, int idx1, int idx2) { int tmp = array[idx1]; array[idx1] = array[idx2]; array[idx2] = tmp; }... void selectionsort (int[] array) { int marker = array.length 1; while (marker>=0) { // bestimme größtes Element int max = 0; for (int i = 1; i<=marker; i++) { if (array[i] > array[max]) max = i; // tausche das markierte mit dem größten swap (array, marker, max); marker--; } }... 35
Vorgehen: Sortieren durch Vertauschen: BubbleSort Folge immer wieder durchlaufen und dabei benachbarte Elemente in die richtige Reihenfolge bringen Größere Elemente überholen so die kleineren und drängen ans Ende der Folge Vorstellung: Bei einer vertikalen Anordnung der Elemente der Folge sortieren sich diese selbst wie aufsteigende Blasen in einer Flüssigkeit, da die großen die kleinen überholen 36
Sortieren durch Vertauschen (1) 1. Durchlauf 5 1 8 3 9 2 1 5 8 3 9 2 1 5 3 8 9 2 2. Durchlauf 1 5 3 8 2 9 1 3 5 8 2 9 3. Durchlauf 1 3 5 2 8 9 4. Durchlauf 1 3 2 5 8 9 5. Durchlauf 1 2 3 5 8 9 37
Sortieren durch Vertauschen (2) Algorithmus (Java-Implementierung)... static void bubblesort (int[] array) { boolean swapped; do { swapped = false; for (int i=0; i<array.length 1; i++) { if (array[i] > array[i+1]) { // Elemente vertauschen swap(array, i, i+1); swapped = true; } } // solange Vertauschung auftritt } while (swapped); }... 38
Sortieren durch Mischen: MergeSort Bisherige Verfahren benötigten direkten Zugriff, d.h. nur für internes Sortieren geeignet Was wenn die Daten nicht in den Hauptspeicher passen? Sortieren in zwei Phasen Die Folge wird in Teile zerlegt, die jeweils in den Hauptspeicher passen und daher getrennt voneinander mit internen Verfahren sortiert werden können. Diese sortierten Teilfolgen werden wieder in Dateien ausgelagert Anschließend werden die Teilfolgen parallel eingelesen und gemischt, indem jeweils das kleinste Element aller Teilfolgen gelesen und in die neue Folge (d.h. wieder in eine Datei) geschrieben wird Auch für internes Sortieren anwendbar Mischen der Teilfolgen durch rekursiven Aufruf von MergeSort 39
Sortieren durch Mischen (1) Eingabe: eine zu sortierende Folge F Ausgabe: eine sortierte Folge Fsorted Algorithmus (Pseudocode-Notation) if F einelementig then return F else Teile F in F1 und F2; F1 := MergeSort(F1); F2 := MergeSort(F2); return Merge(F1,F2); fi 40
Sortieren durch Mischen (2) Split 5 1 8 3 9 2 5 1 8 3 9 2 5 1 8 3 9 2 5 1 3 9 Merge 1 5 3 9 1 5 8 2 3 9 1 2 3 5 8 9 41
Merge(F1,F2) Sortieren durch Mischen (3) Eingabe: zwei zu sortierende Folgen F1, F2 Ausgabe: eine sortierte Folge F Algorithmus (Pseudocode-Notation) F := leere Folge; while F1 oder F2 nicht leer do Entferne das kleinere der Anfangselemente aus F1 bzw. F2; Füge dieses Element an F an od; Füge die verbliebene nichtleere Folge F1 oder F2 an F an; return F 42
Sortieren durch Mischen (4) Algorithmus (Java-Implementierung) void msort (int[] array, int le, int ri) { int i, j, k; int[] b = new int[array.length]; if (ri > le) { int mid = (ri+le)/2; msort(array,le,mid); msort(array, mid+1, ri); // Hilfsfeld konstruieren for (k=le; k<=mid; k++) b[k] = array[k]; for (k=mid; k<ri;k++) b[ri+mid-k] = array[k+1]; // Mischen i = le; j = ri; for (k=le;k<=ri;k++) if (b[i]<b[j]) array[k] = b[i++]; else array[k] = b[j--]; } } void mergesort (int[] array) { msort(array,0,array.length-1); } 43
Quicksort (1) Rekursiver Algorithmus, der von C. A. R. Hoare erfunden wurde Häufig eingesetztes Sortierverfahren In den meisten Fällen ist Quicksort sehr effizient Ähnliches Prinzip wie Mergesort: Teile und herrsche Verbesserung gegenüber Mergesort: Mischvorgang wird vermieden 44
Vorgehen: Quicksort (2) Folge [E l,..., E r ] in zwei Teilen zerlegen, E p ist dabei das Referenzelement (Pivot-Element) Auswahl des Pivot-Elements: typischerweise wird das mittlere Element ausgewählt Folge [E l,..., E p-1 ] von links nach rechts durchlaufen, bis ein Element E i gefunden wurde mit E i E p Folge [E p+1,..., E r ] von rechts nach links durchlaufen, bis ein Element E k gefunden wurde mit k E p Vertausche E k und E i Wiederhole bis alle Elemente [E l,..., E p-1 ] kleiner oder gleich E p sind Wiederhole bis alle Elemente [E p+1,..., E r ] größer oder gleich E p sind Sortiere die Folgen [E l,..., E p-1 ] und [E p+1,..., E r ] E 45
Quicksort (3) 46
QuickSort(F,u,o) Quicksort (4) Eingabe: eine zu sortierende Folge F Ausgabe: eine sortierte Folge F, die untere und obere Grenze u, o Algorithmus (Pseudocode-Notation) if 0>u then i:= Zerlege (F,u,o) Quicksort(F,u,i-1) Quicksort(F,i+1,o) fi 47
Quicksort (5) Zerlege (F,u,o) Eingabe: eine zu zerlegende Folge F, die untere und obere Grenze u und o Ausgabe: Position z der Zerlegung p:=(u+o)/2 while u<= o do l:= Index des ersten Elementes aus dem Bereich u...p-1 mit F[l]>= F[p]; r:= Index des ersten Elements aus dem Bereich p+1...o mit F[r]<F[p]; if l<=r then Tausche F[l] und F[r]; u:= l+1; o:= r-1; fi od return o 48
Quicksort Algorithmus (Java-Implementierung) void qsort (int[] array, int le, int ri) { int lo = le, hi = ri; if (hi > lo) { // Pivotelement bestimmen int mid = array[(lo + hi) / 2]; while (lo <= hi) { // Erstes Element suchen, das größer oder gleich dem // Pivotelement ist, beginnend vom linken Index while (lo < ri && array[lo] < mid) ++lo; // Element suchen, das kleiner oder gleich dem // Pivotelement ist, beginnend vom rechten Index while (hi > le && array[hi] > mid) --hi; // Wenn Indexe nicht gekreuzt --> Inhalte vertauschen if (lo <= hi) { swap(array, lo, hi); ++lo; --hi;} } // Linke Partition sortieren if (le < hi) qsort (array, le, hi); // Rechte Partition sortieren if (lo < ri) qsort( array, lo, ri); } } void quicksort (int[] array) { qsort (array, 0, array.length - 1); } 49
Aufwand von Algorithmen (1) Die Ausführung von Algorithmen verursacht Aufwand in Form von Zeit Speicherverbrauch In zeitkritischen Anwendungen (z.b. Flugzeugsteuerung) ist die Bestimmung des Aufwands unerlässlich Die Komplexität eines Algorithmus bezeichnet die Abschätzung des Aufwands seiner Ausführung auf einem Rechner. 50
Aufwand von Algorithmen (2) Bei der Aufwandsschätzung werden typischerweise folgende Abschätzungsfälle betrachtet Best-case: Aufwand im besten Fall Worst-case: Aufwand im schlechtesten Fall Average-case: Aufwand im durchschnittlichen Fall Abschätzung der Rechenzeit: Zählen, wie häufig eine bestimmte Art von Operationen ausgeführt wird, z.b. Vergleiche Vertauschungen Multiplikationen 51
Aufwand von Algorithmen (3) Die Aufwandsschätzung wird durch die O-Notation ausgedrückt Ab einem bestimmten n wächst f(n) nicht stärker als g(n), damit kann g als Abschätzung für f verwendet werden 52
Komplexitätsklassen O(1): konstanter Aufwand (z. B. Ausdrucksberechnungen) O(log n): logarithmischer Aufwand (z. B. allgemeine Suchverfahren) O(n): linearer Aufwand (z. B. syntaktische Programmanalyse) O(n log n) quasilinearer Aufwand (z. B. Sortierung) O(n2): quadratischer Aufwand (z. B. Vektormultiplikation) O(nk): polynomialer Aufwand (z. B. Matrizenmultiplikation (n3)) O(2 n ): exponentieller Aufwand (z. B. entscheidungsbasierte Spiele) 53
Grundideen von Algorithmen (1) Teile und herrsche Zerlege das Problem in kleinere Teilprobleme Löse diese Teilprobleme Setze die Teillösungen zusammen. Beispiele: Quicksort, Mergesort Dynamische Programmierung Zerlege das Problem in kleinere Teilprobleme und bilde alle möglichen Kombinationen Löse diese Teilproblem-Kombinationen Wähle die beste Kombination Beispiele: Wortproblem bei beliebigen kontextfreien Sprachen 54
Grundideen von Algorithmen (2) Schrittweise Verfeinerung Verbessere eine Näherungslösung. Beispiel: Maximaler Fluss in Netzen Exhaustive Suche ( brute force ) Konstruiere der Reihe nach alle zulässigen Lösungen wähle die optimale Beispiele: Problem des Handlungsreisenden, Wortproblem bei kontextsensitiven Sprachen 55
Such- und Sortierverfahren Suche Binäre Suche Sequentielle Suche Sortierverfahren InsertionSort Selectionsort Bubblesort Mergesort Quicksort Zusammenfassung Aufwand von Algorithmen Entwurfsparadigmen von Algorithmen 56