Gliederung. 5. Compiler. 6. Sortieren und Suchen. 7. Graphen

Transkript

1 5. Compiler Gliederung 1. Struktur eines Compilers 2. Syntaxanalyse durch rekursiven Abstieg 3. Ausnahmebehandlung 4. Arrays und Strings 6. Sortieren und Suchen 1. Grundlegende Datenstrukturen 2. Bäume 3. Streuspeicherung 7. Graphen 1. Darstellung und Topologisches Sortieren 2. Kürzeste Wege 3. Fluß- und Zuordnungsprobleme

2 Vollständige Bäume Ein Baum B heißt vollständiger Baum falls: Für alle k < Tiefe t(b) gilt : Die k-te Schicht ist voll besetzt, (d.h. B besitzt 2 k-1 Knoten der Tiefe k) Die letzte Schicht ist (von links nach rechts gelesen) bis zu einer bestimmten Position p voll besetzt p 2

3 Vollständige Bäume: Eigenschaften Falls die Die Knoten eines vollständigen Baumes in Levelorder nummeriert werden, so gilt: Die Wurzel hat Nummer 1 Hat Knoten k die Nummer i, so haben seine Nachfolger die Nummern 2*i und 2*i+1 Analog dazu: Hat Knoten k die Nummer j (> 1), dann hat sein Vorgänger die Nummer j / 2 3

4 Vollständige Bäume: Beispiel Nummer des Knotens

5 Speicherung vollständiger Bäume (1) Ein vollständiger Baum kann in einem Array gespeichert werden Alle Array-Elemente A[1],..., A[N] enthalten einen Baumknoten A[i /2] enthält den Vorgänger von A[i] A[2*i] und A[2*i+1] enthalten den linken und rechten Nachfolger von A[i] 5

6 Speicherung vollständiger Bäume (2) 1 W 2 S 3 R E G J P B D 9 W S R E G J P B D

7 Heap (Halde) Ein Binärbaum B heißt Halde (engl.: heap), falls folgendes gilt: B ist ein vollständiger Baum Der Schlüssel eines jeden Knoten ist kleiner (oder gleich ) als die Schlüssel seiner Kinder: Diese partielle Ordnung wird auch als Heap-Eigenschaft bezeichnet Heap-Eigenschaften: Form: Vollständiger Baum Ordnung: Entlang jedes Pfades von einem Knoten zur Wurzel sind die Knoteninhalte aufsteigend sortiert. 7

8 Heap: Beispiel

9 Heap Eigenschaften Ein Heap lässt sich durch ein Array darstellen Falls ein Heap durch ein ein Array A implementiert wird, so lautet die Ordnungs-Eigenschaft (Heap-Eigenschaft): A[2*i] A[i] und A[2*i +1] A[i] für alle i= 1,..., n Das kleinste Element steht immer in A[1] 9

10 Einfügen in Heap Beim Einfügen eines Elementes in ein Heap muss wegen der Vollständigkeits-Forderung die Stelle A[n+1] belegt werden Dadurch kann aber die Ordnungseigenschaft verletzt werden: Die Operation upheap wird verwendet, um die Ordnungseigenschaft wieder herzustellen Vorgehensweise: Bewege einen Knoten entlang des Pfades zur Wurzel so weit nach oben, bis die Heap-Eigenschaft wiederhergestellt ist 10

11 Einfügen in Heap (1) 55 einfügen Vergleich 11

12 Einfügen in Heap (2) 25 einfügen Vergleich

13 10 einfügen Einfügen in Heap (3)

14 Element von der Wurzelposition löschen: (1) Das Entfernen eines Elements von der Wurzelposition hinterlässt eine Lücke im Heap: Dadurch ist die Heap- Eigenschaft verletzt Die Lücke im Heap kann durch das letzte Element im Heap (das am weitesten rechts befindliche Element) gefüllt werden Die Operation DownHeap (Versickern) wird verwendet, um die Ordnungseigenschaft wieder herzustellen Vorgehensweise: Bewege einen Knoten entlang eines Pfades von der Wurzel so weit nach unten, bis die Heap- Eigenschaft wiederhergestellt ist. 14

15 Element von der Wurzelposition löschen: (2)

16 Element von der Wurzelposition löschen: (3)

17 Element von der Wurzelposition löschen: (4)

18 Operation Versickern (DownHeap) class Heap { void Versickern(Comparable A[],int i,int n) { while ( 2*i <= n) { // i hat linken Sohn int j = 2*i; //A[j] ist linker Sohn von A[i] if ( j < n && (A[ j ].compareto( A[ j+1 ] ) < 0) ) j = j + 1; // 2i+1 ist kleinerer Knoten if (A[i]. compareto(a[j]) > 0 ) { swap(a,i,j); i = j; // versickere weiter } else i //Heap-Eigenschaft erfüllt break; } 2i 2i+1... } } Ist A[i] größer A[j]? 1

19 Heapsort Sortieren einer Menge von Schlüsseln kann durch n-maliges Extrahieren des Minimums aus der Menge implementiert werden Vorgehensweise: Die zu sortierende Menge mit n Elementen wird zuerst in eine Heap- Struktur überführt Folgende Schritte werden n-mal hintereinander ausgeführt: Minimum entfernen (Minimum steht an der Wurzel) Entstehende Lücke durch das letzte Element im Heap füllen Heap-Eigenschaft durch Versickern wiederherstellen 19

20 Erzeugung einer Heap-Struktur (1) Ausgangspunkt: Vollständiger Baum bzw. unsortiertes Array Merke: Bei n Elementen erfüllen die Elementen mit den Positionen n / 2 + 1,..., n bereits die Heap-Eigenschaft (Blätter). Die Herstellung der Heap-Eigenschaft kann mit Elementen mit den Positionen n / 2,..., 1 durch Versickern durchgeführt werden 1 5 n=6, Heap-Eigenschaft für die Elemente 3, 9 und 2 bereits erfüllt 3 9 Heap-Eigenschaft für die Elemente, 1 und 5 muss ggf. hergestellt werden

21 Erzeugung einer Heap-Struktur (2)

22 Erzeugung einer Heap-Struktur (3)

23 Erzeugung einer Heap-Struktur (4)

24 Erzeugung einer Heap-Struktur class Heap { public void heapify (Comparable A[]) { // verwandle A in einen Heap int n = A.length-1; for (int i = n/2; i >= 1; i--) { Versickern(A,i,n); }... } 24

25 1 Heapsort: Beispiel (1) Heap herstellen

26 2 Heapsort: Beispiel (2) Heap herstellen

27 Heapsort: Beispiel (3) Heap herstellen

28 5 Heapsort: Beispiel (4)

29 Heapsort-Algorithmus class Heap { public Heapsort (Comparable A[]){ heapify(a); // Erzeuge Heap for (int i = A.length-1; i >= 2; i--) { swap(a,1,i); Versickern(A,1,i-1); // versickere Wurzel } } } 29

30 Aufwand von Heapsort Aufwand für den Heap-Aufbau: Aufwand für das Durchsickern eines Elementes multipliziert mit der Anzahl der Elemente n Der Aufwand für das Durchsickern im Heap entspricht im im ungünstigsten der Tiefe des Heaps: log 2 n Insgesamt ergibt sich einen Aufwand von n/2 log 2 n Aufwand für das Entfernen von Elementen aus dem Heap: Das Entfernen erfolgt für jedes Element, wobei der Aufwand für die Wiederherstellung der Heap- Eigenschaft beträgt wieder log 2 n Insgesamt ergibt sich einen Aufwand von n log 2 n Der Aufwand für den Heapsort-Algorithmus ist von der Ordnung O(n log n) Merke Heapsort arbeit im Durchschnitt wie Quicksort und Mergesort Im ungünstigsten Fall hat Heapsort einen Aufwand von O(n log n), während Quicksort z.b. O(n 2 ) benötigt 30