In dieser Woche: ungerichtete Graphen

1. In dieser Woche: ungerichtete Graphen

2. Wir müssen also überlegen: • Implementierung der Knoten, • Implementierung der Kanten, • daraus: Implementierung des Graphen insgesamt. Annahme: die Knoteninhalte sind Zeichenketten (Vereinfachung - Knoteninhalte können beliebig komplex sein). Zunächst: Operationen auf Knoten

3. Prinzip: Information Hiding (Verbergen von Informationen). Allgemein: Information sollten von Benutzern einer Struktur nur gelesen werden können. Änderungen sollten durch Funktions- aufrufe kontrollierbar sein. • Grund: Programme als Kontrakt • zwischen Aufrufern und Akteuren, • die Aufrufer garantieren Eigenschaften von Werten, • die Akteure garantieren wohldefiniertes Verhalten, • Das geht nur durch Kontrolle des Zugriffsverhaltens.

4. Konsequenzen: • Daten in einer struct möglichst private • Zugriff: lesend und schreibend durch geeignete Funktionen. Beispiel: struct Bsp { int a; char b; }; Es sei deklariert: Bsp X; X.a = 1 und cout << X.a sind möglich, also schreibender und lesender Zugriff.

5. struct Bsp2 { private: int a; public: Setze(int); int Lese(); char b; }; Insbesondere kann jedes Programm, das auf X zugreifen kann, X.a ändern, ohne daß X selbst davon erfährt. Deklariere Bsp2 Y; Y.a ist illegal und wird vom Compiler zurückgewiesen.

6. struct Bsp2 { private: int a; public: void Setze(int); int Lese(); char b; }; void Bsp2::Setze(int x) { a = x; } int Bsp2::Lese() { return a; } • Bsp2 Y • sei deklariert. • Y.a ist ein illegaler Ausdruck, • Y.b dagegen nicht, • Zugriff auf Y.alesend nur durchY.Lese(),schreibend (also verändernd) nur durchY.Setze(33).

7. Inhalt: Zeichenkette unbestimmter Länge Weitere Felder • Konsequenz: • wenn die Inhalte der Knoten des Graphen nicht von außen (d.h. durch beliebige Benutzer) geändert werden sollen, so sollte der Inhalt als private deklariert werden. • Weiterhin sind Definitions- und Leseoperationen notwendig. struct Knoten { private: char * Inhalt; .... public: void SetzeWert(char *); char * LeseWert(); .... };

8. Verschaffe mir ein entsprechend großes Feld. Stelle Länge der Zeichenkette fest Zuweisung void Knoten::SetzeWert(char *s) { for (int j = 0; s[j++] != '\0'; ); Inhalt = new char [--j]; Inhalt = s; ... } char * Knoten::LeseWert() {return Inhalt;}

9. Alter Bekannter Die üblichen Konstanten Weitere Operationen: int Gleich(Knoten *); Gegeben ein Knoten, möchte feststellen, ob sein Inhalt gleich dem des aktuellen Knotens ist: int Knoten::Gleich(Knoten * K) { int strcmp(char *, char *); return (strcmp((*K).Inhalt, Inhalt) == 0? true: false); }

10. Die Adjazenzlisten zu einem Knoten werden in einer verketteten Liste verwaltet. Ergibt ein private Attribut Adjazenz mit entsprechenden Funktionen: struct Knoten { private: char * Inhalt; Knoten * Adjazenz; ... public: void SetzeWert(char *); char * LeseWert(); int Gleich(Knoten *); ... Knoten * LeseAdjazenz(); void SetzeAdjazenz(Knoten *); };

11. Knoten * Knoten::LeseAdjazenz() { return Adjazenz; } Das sollte klar sein. void Knoten::SetzeAdjazenz(Knoten * K) { Knoten * L = new Knoten; ...; L->SetzeWert(K->LeseWert()); L->Adjazenz = Adjazenz; Adjazenz = L; }

12. Erzeuge also einen neuen Knoten L • kopiere die Zeichenkette von K (dem Parameter) nach L: L->SetzeWert(K->LeseWert()); • füge L an den Anfang der Adjazenzliste des KnotensL->Adjazenz = Adjazenz • das ist dann die Adjazenzliste des Knotens:Adjazenz = L

13. Schließlich werden die Knoten miteinander verkettet (Verwaltungsinformation, die nichts mit dem Graphen selbst zu tun hat). Inhalt Ver- waltung * Adjazenz- liste *

14. Vollständige Definition von Knoten: struct Knoten { private: char * Inhalt; Knoten * Adjazenz; Knoten * Verwaltung; public: void SetzeWert(char *); char * LeseWert(); int Gleich(Knoten *); Knoten * LeseVerwaltung(); Knoten * LeseAdjazenz(); void SetzeVerwaltung(Knoten *); void SetzeAdjazenz(Knoten *); void Druck(char *, char *); };

15. Setze den neuen Knoten an den Anfang der Verwaltungsliste Knoten * Knoten::LeseVerwaltung() { return Verwaltung; } (ist wieder trivial) void Knoten::SetzeVerwaltung(Knoten * K) { K->Verwaltung = Verwaltung; Verwaltung = K; }

16. Datei für die Ausgabe Texte, in denen der Inhalt eingebettet werden kann (z. B. „\t“ oder „\n“) Schließlich: Drucken void Knoten::Druck(char * vor, char * nach) { *ausgabe << vor << Inhalt << nach; }

17. Sozusagen Basisschicht im Schichtenmodell: Definition des Graphen und seiner Grundoperationen eine klitzekleine Zwischenschicht Definition von Knoten und ihrer Grundoperationen

18. Zwischenschicht • dient zur Realisierung von hilfreichen Operationen auf Knoten des Graphen • Operationen sind freilich nicht so vital für die Knoten, daß sie in die Knoten-Definition aufhgenommen werden müßten. • es handelt sich dabei um: • Finden eines Knoten in der Verwaltungsliste eines anderen, • Einfügen eines Knoten in dieser Liste, • Finden eines Knoten in der Adjazenzliste eines anderen, • Drucken der Adjazenzliste eines Knoten.

19. int VerwFinde(Knoten *K, Knoten *L) { if (L == NULL) return false; else return (K->Gleich(L) ? true: VerwFinde(K, L->LeseVerwaltung())); } Knoten * VerwEinfuegen(Knoten * K, Knoten * L){ int VerwFinde(Knoten *, Knoten *); if (!VerwFinde(K, L)) K->SetzeVerwaltung(L); return K; }

20. int AdjFinde(Knoten *K, Knoten *L) { if (L == NULL) return false; else return (K->Gleich(L) ? true: AdjFinde(K, L->LeseAdjazenz())); } void ListenDruck(Knoten *L) { if (L == NULL) *ausgabe << "}," << endl; else { *ausgabe << L->LeseWert() << (L->LeseAdjazenz() == NULL ? "" : ", "); ListenDruck(L->LeseAdjazenz()); } }

21. Analoges Vorgehen bei der Formulierung des Graphen: • welche Komponenten sind private? • welche Operationen werden benötigt? • Hilfsoperationen wieder versteckt, damit zweifache Funktion der private-Deklaration: • Schützen vor unberechtigtem Zugriff, • Verbergen von Funktionen, die nicht außerhalb eines wohldefinierten lokalen Kontexts aufgerufen werden sollten.

22. Der Graph besteht zunächst aus einem Zeiger auf einen Knoten (ähnlich der Wurzel bei binären Suchbäumen) und der Initialisierung: struct Graph { private: Knoten * EinKnoten; ... public: void Init(); ... };

23. Ein Knoten? (Ganz Gallien?) Über die Verwaltungsinformation werden alle anderen Knoten eingefügt. Die Initialisierung ist ziemlich trivial: void Graph::Init() { EinKnoten = NULL; }

24. Hilfsfunktion: Nachsehen, wo ein Knoten auf der Verwaltungsliste eines anderen steckt; ein Zeiger auf diesen Knoten wird zurückgegeben. Wird als private vereinbart, da nur lokal verwendet. Knoten * Graph::DaIstDerKnoten(Knoten * K, Knoten * Wo) { if (Wo == NULL) return NULL; else if (K->Gleich(Wo) == true) return Wo; else return DaIstDerKnoten(K, Wo->LeseVerwaltung()); }

25. Weiter: Testfunktionen • ist ein Knoten mit einem bestimmten Inhalt im Graphen vorhanden? • sind zwei Knoten mit einer Kante verbunden? int Graph::KnotenTesten(Knoten * K) { if (DaIstDerKnoten(K, EinKnoten) != NULL ?) return true; else return false; }

26. int Graph::KanteTesten(Knoten * K, Knoten * L) { Knoten * OK = DaIstDerKnoten(K, EinKnoten); return (OK == NULL ? false : AdjFinde(OK, L)); } • Also: • suche den Knoten K in der Verwaltungsliste vonEinKnoten, • ist der Knoten nicht vorhanden (d.h. wird NULL zurück- gegeben), kann keine Kante vorhanden sein, • sonst: suche in der Adjazenzliste des Resultatknotens nach dem Knoten L.

27. Stand der Dinge: struct Graph { private: Knoten * EinKnoten; Knoten * DaIstDerKnoten(Knoten *, Knoten *); public: void Init(); int KnotenTesten(Knoten *); int KanteTesten(Knoten *, Knoten *); ... };

28. Nur falls der Knoten noch nicht vorhanden ist, wird er in die Verwaltungsliste eingefügt. Sehe nach, ob überhaupt schon ein Knoten vorhanden ist. Ziemlich kanonisch: Einfügen von Knoten und Kanten: void Graph::KnotenEinfuegen(Knoten * K) { if (EinKnoten == NULL) EinKnoten = K; else if (!KnotenTesten(K)) EinKnoten->SetzeVerwaltung(K); }

29. Überprüfe, ob die Kante bereits vorhanden ist, sonst setze die Adjazenzfelder beider Knoten entsprechend. Schaue nach, ob die Knoten überhaupt schon vorhanden sind, füge sie ggf. ein. Einfügen einer Kante zwischen zwei Knoten: void Graph::KanteEinfuegen(Knoten *K, Knoten *L) { if (!KnotenTesten(K)) KnotenEinfuegen(K); if (!KnotenTesten(L)) KnotenEinfuegen(L); if (!KanteTesten(K, L)) { K->SetzeAdjazenz(L); L->SetzeAdjazenz(K); } }

30. Schließlich, als Hilfsfunktionen: • Konstruiere aus einer Zeichenkette einen neuen Knoten im Graphen (MkKnoten), • Druck des gesamten Graphen.

31. Konstruiere einen Knoten mit dem Inhalt-Feld Schaue nach, ob ein Knoten mit diesem Inhalt bereits im Graphen vorhanden ist Setze Rückgabewert entsprechend Knoten * Graph::MkKnoten(char * s) { Knoten * K = new Knoten, * L; K->SetzeWert(s); L = DaIstDerKnoten(K, EinKnoten); return (L == NULL ? K : L); }

32. Drucken: • drucke jeden Knoten, • drucke für jeden Knoten seine Adjazenzliste (kommt aus der Zwischenschicht). void Graph::Druck(char * vor, char * nach) { void ListenDruck(Knoten *); for (Knoten * K = EinKnoten; K != NULL; K = K->LeseVerwaltung()) { *ausgabe << "ADJ("; K->Druck(vor, nach); ListenDruck(K->LeseAdjazenz()); } }

33. Insgesamt sieht die struct so aus: struct Graph { private: Knoten * EinKnoten; Knoten * DaIstDerKnoten(Knoten *, Knoten *); public: void Init(); Knoten * MkKnoten(char *); int KnotenTesten(Knoten *); int KanteTesten(Knoten *, Knoten *); void KnotenEinfuegen(Knoten *); void KanteEinfuegen(Knoten *, Knoten *); void Druck(char *, char *); };

34. (Beispielgraph) void main() { Graph * G = new Graph; char * ara[] = {"\t", "eins", "zwei", "drei", "vier", "fünf", "sechs", "sieben"}; Knoten * MkKnoten(char *), * K[8]; G->Init(); for (int i = 1; i < 8; i++) K[i] = G->MkKnoten(ara[i]); G->KanteEinfuegen(K[1], K[2]); ... G->KanteEinfuegen(K[6], K[7]); G->Druck("", ") = {"); }

35. Ausgabe: ADJ(eins) = {sieben, sechs, zwei}, ADJ(sieben) = {sechs, fünf, vier, drei, zwei, eins}, ADJ(sechs) = {sieben, eins, fünf}, ADJ(fünf) = {sieben, sechs, vier}, ADJ(vier) = {sieben, fünf, drei}, ADJ(drei) = {sieben, vier, zwei}, ADJ(zwei) = {sieben, drei, eins}, Programm: prog-25.cpp