Chair of Software Engineering Einfhrung in die Programmierung
- Slides: 106
Chair of Software Engineering Einführung in die Programmierung Prof. Dr. Bertrand Meyer Lektion 15: Topologisches Sortieren Teil 1: Problemstellung und mathematische Basis Teil 2: Algorithmus und Implementation
Teil 1 Problemstellung und mathematische Basis 2
by Caran d’Ache
“Topologisches Sortieren” Aus einer gegebenen partiellen Ordnung eine totale Ordnung produzieren. 4
Die Problemstellung Aus einer gegebenen partiellen Ordnung eine totale Ordnung produzieren Partielle Ordnung: Ordnungsbedingung zwischen Elementen einer Menge, z. B. “Das Abwaschen kommt vor der politischen Diskussion” Ø “Die Wanderung auf den Üetliberg kommt vor dem Essen” Ø “Das Medikament muss vor dem Essen eingenommen werden” Ø “Das Essen kommt vor dem Abwaschen” Ø Totale Ordnung: Eine Sequenz, die alle Elemente der Menge beinhaltet Kompatibel: Die Sequenz berücksichtigt alle Ordnungsstrukturen Üetliberg, Medikament, Essen, Abwaschen, Politik : OK Ø Medikament, Üetliberg, Essen, Abwaschen, Politik : OK Ø Politik, Medikament, Essen, Abwaschen, Üetliberg : not OK Ø 5
Warum dieses Beispiel wichtig ist Ø Häufiges Problem, präsent in vielen verschiedenen Gebieten Ø Interessanter, nicht trivialer (aber auch nicht zu komplizierter) Algorithmus Ø Erläutert die Techniken von Algorithmen, Datenstrukturen, Komplexität und anderen Themen der letzten Lektion Ø Erklärt Techniken des Software-Engineerings Ø Beschreibt wichtige mathematische Konzepte: binäre Relationen und im Speziellen Ordnungsrelationen Ø Es ist einfach schön! Heute: Problemstellung und mathematische Basis Nächstes Mal: Algorithmus und Konzept im Detail 6
Topologisches Sortieren: Anwendungsbeispiele Ø „Erzeuge aus einem Wörterbuch eine Liste von Definitionen („Glossar“), so dass kein Wort vor seiner Definition steht“ Ø Erstellung eines kompletten Zeitablaufs für die Ausführung von Aufgaben mit Ordnungsauflagen (Häufige Anwendung: „Scheduling“ von Unterhaltsarbeiten in der Industrie, oft mit tausenden von Einschränkungen) Ø Eine neue Version einer Klasse mit neuer Reihenfolge der Features generieren, so dass kein Feature ein anderes, vor ihm deklariertes aufruft 7
Rechtecke mit Überlappungsauflagen Bedingungen: [B, A], [D, A], [A, C], [B, D], [D, C] C B A D E 8
Rechtecke mit Überlappungsauflagen darstellen Bedingungen: [B, A], [D, A], [A, C], [B, D], [D, C] Mögliche Reihenfolge der Anzeige: B D E A C C B A D E B A C D E 9
Ein Beispiel in Eiffel. Studio Um x. f mit dynamischem Binden zu implementieren, brauchen wir eine Tabelle der Routinen Klassen (Typen) put LINKED_LIST Routinenzeiger Void 10
Eine Übung! Finden Sie, im Eiffel. Studio-Quellcode, die Namen der Datenstrukturen, die Tabelle oder Tabellen der vorhergehenden Folie darstellen 11
Die Problemstellung Aus einer gegebenen partiellen Ordnung eine totale Ordnung produzieren Partielle Ordnung: Ordnungsbedingung zwischen Elementen einer Menge, z. B. “Das Abwaschen kommt vor der politischen Diskussion” Ø “Die Wanderung auf den Üetliberg kommt vor dem Essen” Ø “Das Medikament muss vor dem Essen eingenommen werden” Ø “Das Essen kommt vor dem Abwaschen” Ø Totale Odnung: Eine Sequenz, die alle Elemente der Menge beinhaltet Kompatibel: Die Sequenz berücksichtigt alle Ordnungsstrukturen Üetliberg, Medikament, Essen, Abwaschen, Politik : OK Ø Medikament, Üetliberg, Essen, Abwaschen, Politik : OK Ø Politik, Medikament, Essen, Abwaschen, Üetliberg : not OK Ø 12
Als Graph dargestellt Üetliberg Essen Abwaschen Politik Medikament “Das Abwaschen kommt vor der politischen Diskussion” “Die Wanderung auf den Üetliberg kommt vor dem Essen” “Das Medikament muss vor dem Essen eingenommen werden” “Das Essen kommt vor dem Abwaschen” 13
Manchmal gibt es keine Lösung Ø “Die Einführung der Rekursion erfordert, dass die Studenten Stapel kennen. “ Ø “Abstrakte Datentypen müssen vor Stapel behandelt werden. Ø “Abstrakte Datentypen beruhen auf Rekursion” Die Bedingungen erzeugen einen ZYKLUS (Kreis). 14
Allgemeine Struktur (1) Gegeben: Ein Typ G Eine Menge von Elementen vom Typ G Eine Menge von Bedingungen zwischen diesen Elementen Benötigt: Eine Aufzählung der Elemente in einer zu den Bedingungen kompatiblen Ordnung class ANORDENBAR [G ] feature elemente : LIST [G ] auflagen : LIST [TUPLE [G, G ]] topsort : LIST [G ]. . . ensure kompatibel (Result, auflagen) end 15
Ein wenig mathematischer Hintergrund… 16
Binäre Relationen auf einer Menge Eine Eigenschaft zwischen zwei Elementen der Menge, die entweder erfüllt oder nicht erfüllt ist. Beispielrelationen auf einer Menge von Personen PERSON : Ø Mutter : a Mutter b ist erfüllt genau dann, wenn a die Mutter von b ist Ø Vater : Ø Kind : Ø Schwester : Ø Geschwister : Bemerkung: Relationen werden in grün dargestellt. Notation: a r b, um auszudrücken, dass r für a und b gilt. 17
Beispiel: Die vor-Relation Die Menge: Aufgaben = {Politik, Essen, Medikament, Abwaschen, Üetliberg} Die einschränkende Relation: Abwaschen vor Politik Üetliberg vor Essen Medikament vor Essen vor Abwaschen “Das Abwaschen kommt vor der politischen Diskussion” “Die Wanderung auf den Üetliberg kommt vor dem Essen” “Das Medikament muss vor dem Essen eingenommen werden” “Das Essen kommt vor dem Abwaschen” 18
Einige spezielle Relationen auf einer Menge X universal [X ]: ist für jedes Paar von Elementen in X erfüllt id [X ]: ist für jedes Element in X und sich selbst erfüllt. empty [X ]: ist für kein Paar von Elementen in X erfüllt. 19
Relationen: präzisere mathematische Betrachtung Wir betrachten eine Relation r auf einer Menge P als: Kartesisches Produkt Eine Menge von Paaren aus P x P, die alle Paare [x, y] enthält, so dass x r y. Dann heisst x r y nichts anderes als [x, y] r. Siehe Beispiele auf der nächsten Folie. 20
Eine Relation ist eine Menge: Beispiele son = {[Charles, Elizabeth], [Charles, Philip], [William, Charles], [Harry, Charles]} Natürliche Zahlen id [ℕ] = {[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], …} universal [ℕ] = {[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], … [1, 0], [1, 1], [1, 2], [1, 3], [1, 4], … [2, 0], [2, 1], [2, 2], [2, 3], [2, 4], … …} empty [X ] = ℕ x ℕ = = {} 21
Illustration der Relationen id [ℕ] 6 5 4 universal [ℕ] 3 2 1 0 0 1 2 3 4 5 6 22
Beispiel: Die vor-Relation “Das Abwaschen kommt vor der politischen Diskussion” “Die Wanderung auf den Üetliberg kommt vor dem Essen” “Das Medikament muss vor dem Essen eingenommen werden” “Das Essen kommt vor dem Abwaschen” Unsere Menge: elemente = {Politik, Essen, Medikament, Abwaschen, Üetliberg} Die einschränkende Relation: vor = {[Abwaschen, Politik], [Üetliberg, Essen], [Medikament, Essen], [Essen, Abwaschen]} 23
Als Graph dargestellt Üetliberg Essen Abwaschen Politik Medikament “Das Abwaschen kommt vor der politischen Diskussion” “Die Wanderung auf den Üetliberg kommt vor dem Essen” “Das Medikament muss vor dem Essen eingenommen werden” “Das Essen kommt vor dem Abwaschen” 24
Einfache Operationen auf eine Menge Konvention: Sie sind ihr eigenes Geschwister. Ehemann Geschwister = Schwester Bruder id [Person] Schwester Geschwister Vater Vorfahre Gatte = Ehefrau universal [X ] = X x X empty [X ] = 25
Mögliche Eigenschaften einer Relation (Auf einer Menge X. Alle Definitionen müssen für jedes Element von X erfüllt sein. ) Total*: (a b) ((a r b) (b r a)) Reflexiv: Irreflexiv: ara not (a r a) Symmetrisch: arb bra Antisymmetrisch: (a r b) (b r a) Asymmetrisch: not ((a r b) (b r a)) Transitiv: (a r b) (b r c) a=b arc *Die Definition von “total” ist spezifisch für diese Diskussion (es gibt dafür keine Standarddefinition). Die restlichen Begriffe sind standardisiert. 26
Beispiele (auf einer Menge von Personen) Geschwister Reflexiv, symmetrisch, transitiv Schwester Familienoberhaupt irreflexiv Mutter asymmetrisch, irreflexiv, antisymmetrisch (a Familienoberhaupt b heisst, dass a das Oberhaupt von b’s Familie ist. (Ein Oberhaupt pro Familie)) Total: (a b) (a r b) (b r a) Reflexiv: Irreflexiv: ara not (a r a) Symmetrisch: arb bra Antisymmetrisch: (a r b) (b r a) a = b Asymmetrisch: not ((a r b) (b r a)) Transitiv: (a r b) (b r c) a r c 27
Totale Ordnungsrelation (strikt) Eine Relation ist eine strikte totale Ordnung falls sie folgende Eigenschaften erfüllt: ØTotal ØIrreflexiv Total: (a b) (a r b) (b r a) Reflexiv: Irreflexiv: ara not (a r a) Symmetrisch: arb bra Antisymmetrisch: (a r b) (b r a) a = b Asymmetrisch: not ((a r b) (b r a)) Transitiv: (a r b) (b r c) a r c ØTransitiv Beispiel: “kleiner als” < auf natürlichen Zahlen 0 1 2 3 4 0<1 0 < 2, 0 < 3, 0 < 4, . . . 1<2 1<3 1 < 4, . . . 2<3 2 < 4, . . . 5 28
Theorem Eine strikte (totale) Ordnungsrelation ist asymmetrisch 29
Totale Ordnungsrelation (strikt) Eine Relation ist eine strikte totale Ordnungsrelation, falls sie folgende Eigenschaften erfüllt: ØTotal ØIrreflexiv Total: Reflexiv: Irreflexiv: Symmetrisch: Antisymmetrisch: Asymmetrisch: Transitiv: (a b) (a r b) (b r a) ara not (a r a) arb bra (a r b) (b r a) a = b not ((a r b) (b r a)) (a r b) (b r c) a r c ØTransitiv Theorem: Eine strikte (totale) Ordnungsrelation ist asymmetrisch. 30
Totale Ordnungsrelation ( nicht-strikt ) Eine Relation ist eine nichtstrikte Ordnungsrelation, falls sie folgende Eigenschaften hat: Ø Total Ø Reflexiv Ø Transitiv Ø Antisymmetrisch Total: (a b) (a r b) (b r a) Reflexiv: ara Irreflexiv: not (a r a) Symmetrisch: arb bra Antisymmetrisch: (a r b) (b r a) a = b Asymmetrisch: not ((a r b) (b r a)) Transitiv: (a r b) (b r c) a r c Beispiel: “kleiner als oder gleich” ≤ auf natürlichen Zahlen 0 0≤ 0 1 2 3 4 0 ≤ 1, 0 ≤ 2, 0 ≤ 3, 0 ≤ 4, . . . 1 ≤ 1, 1 ≤ 2, 1 ≤ 3, 1 ≤ 4, . . . 2 ≤ 2, 2 ≤ 3, 2 ≤ 4, . . . 5 31
Totale Ordnungsrelation (strikt) Eine Relation ist eine strikte totale Ordnungsrelation, falls sie folgende Eigenschaften erfüllt: Ø Total Ø Irreflexiv Ø Transitiv Total: (a b) (a r b) (b r a) Reflexiv: ara Irreflexiv: not (a r a) Symmetrisch: a r b b r a Antisymmetrisch: (a r b) (b r a) a = b Asymmetrisch: not ((a r b) (b r a)) Transitiv: (a r b) (b r c) a r c 32
Partielle Ordnungsrelation (strikt) Eine Relation ist eine strikte partielle Ordnungsrelation, falls sie folgende Eigenschaften erfüllt: Ø total Ø irreflexiv Ø transitiv Total: (a b) (a r b) (b r a) Irreflexiv: not (a r a) Symmetrisch: arb bra Antisymmetrisch: (a r b) (b r a) a = b Transitiv: (a r b) (b r c) a r c y 2 [1, 2] [4, 2] b d [0, 1] 1 p a < q falls: • [3, 0] 0 Beispiele: Relation zwischen Punkten in einer Ebene: 1 2 3 c x • xp < xq y p < yq 33
Theoreme partielle Ordnungsrelation ist asymmetrisch Eine strikte (totale) Eine totale Ordnungsrelation ist (auch!) eine partielle Ordnungsrelation (“partiell” heisst eigentlich möglicherweise partiell) 34
Beispiel einer partiellen Ordnung y [1, 2] 2 [4, 2] d b [0, 1] 1 a p < q falls: • xp < xq • y p < yq [3, 0] 0 1 2 Hier gilt: a < b a < d c < d 3 c Keine Verbindung zwischen a und c, b und c : z. B. Weder a < c noch c < a 35
Mögliche topologische Sortierungen y a b c 2 d b 1 a 0 a < b a < d d c a b d a c b d 1 2 3 c c < d 36
Topologisches Sortieren verstanden y 2 d b 1 {[a, b], [a, d], [c, d]} a 0 a < b a < d Hier ist die Relation < 1 2 c < d 3 c Eine Lösung ist: a, b, c, d Wir suchen eine totale Ordnungsrelation t, so dass < t 37
Topologisches Sortieren: Endgültige Problemstellung Aus einer partiellen Ordnung eine kompatible totale Ordnung erzeugen. wobei: Eine partielle Ordnung p ist kompatibel mit einer totalen Ordnung t genau dann, wenn p t 38
Von Bedingungen zu partiellen Ordnungen Ist eine durch folgende Menge von Bedingungen definierte Relation, wie zum Beispiel auflagen = {[Abwaschen, Politik], [Üetliberg, Essen], [Medikament, Essen], [Essen, Abwaschen]} immer eine partielle Ordnung? Üetliberg Medikament Essen Abwaschen Politik 39
Potenzen und transitive Hülle von Relationen r i +1 = r i ; r wobei ; die Zusammensetzung ist Ü M Transitive Hülle r += E P A (Transitive closure) r 1 r 2 . . . -- Immer transitiv r 1 r 2 r 3 40
Reflexive transitive Hülle r 0 = id [X ] r i +1 = r i ; r wobei X die zugrunde liegende Menge ist wobei ; die Zusammensetzung ist Ü M E Transitive Hülle r += r 1 r 2 . . . immer transitiv reflexive transitive Hülle: r * = r 0 r 1 r 2 . . . -- Immer transitiv und reflexiv P A r 0 r 1 r 2 r 3 41
Azyklische Relation Eine Relation r auf einer Menge X ist azyklisch genau dann, wenn: r + id [X ] = Ü M E vor + A P id [X] 42
Azyklische Relationen und partielle Ordnungen Theoreme: Ø Jede (strikte) Ordnungsrelation ist azyklisch Ø Eine Relation ist azyklisch genau dann, ihre transitive Hülle eine (strikte) Ordnung ist (auch: Genau dann, wenn ihre reflexive transitive Hülle eine nicht-strikte partielle Ordnung ist) 43
Von den Bedingungen zur partiellen Ordnung Unsere partielle Ordnungsrelation ist vor + vor = {[Abwaschen, Politik], [Üetliberg, Essen], [Medikament, Essen], [Essen, Abwaschen]} Üetliberg Medikament Essen Abwaschen Politik 44
Was wir gesehen haben Das Problem des topologischen Sortierens und seine Anwendungen Mathematischer Hintergrund: Ø Relationen als Mengen von Paaren Ø Eigenschaften einer Relation Ø Ordnungsrelationen: partiell/total, strikt/nicht-strikt Ø Transitive und reflexive transitive Hüllen Ø Die Beziehung zwischen azyklischen und Ordnungsrelationen Ø Die Grundidee des topologischen Sortierens Als Nächstes: Wie man es implementiert: Ø Effizient: O (m + n) für m Bedingungen und n Elemente Ø Gutes Software-Engineering: effektives API 45
Chair of Software Engineering Einführung in die Programmierung Prof. Dr. Bertrand Meyer Lektion 15: Topologisches Sortieren Teil 2: Algorithmus und Implementation
Zurück zu Software 47
Die Grundidee des Algorithmus p r q tt s v uu w topsort 48
Allgemeine Struktur (erster Versuch) Gegeben: Ein Typ G Eine Menge von Elementen des Typs G Eine Relation auflagen auf diesen Elemente Benötigt: Eine Aufzählung der Elemente, kompatibel mit auflagen. class TOPOLOGISCH_SORTIERBAR [G ] feature auflagen : LINKED_LIST [TUPLE [G, G ]] elemente : LINKED_LIST [G ] topologisch_sortiert : LINKED_LIST [G ] require zyklus_frei (auflagen) do. . . ensure kompatibel (Result, auflagen) end 49
Allgemeine Struktur (verbessert) Wir benutzen statt einer Funktion topologisch_sortiert: • Eine Prozedur führe_aus. • Ein Attribut sortiert (gesetzt von führe_aus), welches das Resultat enthält. class TOPOLOGISCH_SORTIERER [G ] feature auflagen : LINKED_LIST [TUPLE [G, G]] elemente : LINKED_LIST [G ] sortiert : LINKED_LIST [G ] führe_aus require zyklus_frei (auflagen) do. . . ensure kompatibel (sortiert, auflagen) end 50
Fehlende Eindeutigkeit Im Allgemeinen gibt es mehrere Lösungen y a b c 2 d b 1 a 0 d c a b d a c b d 1 2 3 c In der Praxis benutzt das topologische Sortieren ein Optimierungskriterium, um zwischen möglichen Lösungen zu entscheiden. 51
Eine partielle Ordnung ist azyklisch Die Relation < : Muss eine Partielle Ordnung sein: Keine Zyklen in der transitiven Hülle von auflagen. Ø Das heisst es gibt keine zirkuläre Liste der Form e 0 < e 1 < … < en < e 0 Ø Falls es einen solchen Zyklus gibt, existiert keine Lösung für das Problem! 52
Zyklen Bei der topologischen Sortierung erhalten wir nicht die eigentliche Relation < , sondern eine Relation auflagen, durch eine Menge von Paaren wie {[Abwaschen, Hinaus], [Museum, Essen], [Medikament, Essen], [Essen, Abwaschen]} Die Relation, an der wir interessiert sind, ist: + = auflagen < Azyklisch Partielle Ordnung < ist azyklisch genau dann, wenn auflagen keine Paare der Form {[f 0, f 1], [f 1, f 2], …, [fm, f 0]} enthält. Falls ein solcher Zyklus existiert, kann es keine mit auflagen kompatible Ordnung geben. 53
Allgemeine Struktur (Erinnerung) class TOPOLOGISCH_SORTIERER [G ] feature auflagen : LINKED_LIST [TUPLE [G, G]] elemente : LINKED_LIST [G ] sortiert : LINKED_LIST [G ] führe_aus require zyklus_frei (auflagen) do. . . ensure kompatibel (sortiert, auflagen) end 54
Ursprüngliche Annahme führe_aus require zyklus_frei (auflagen) do. . . ensure kompatibel (sortiert, auflagen) end Dies nimmt an, dass der Input keine Zyklen beinhaltet. Eine solche Annahme ist in der Praxis nicht durchsetzbar. Im Speziellen: Das Finden von Zyklen ist in Wirklichkeit gleich schwierig wie topologisches Sortieren! 55
Der Umgang mit Zyklen Wir nehmen gar nichts an, sondern finden die Zyklen als Nebenprodukt beim topologischen Sortieren. Das Schema für führe_aus ergibt sich also zu: --“Versuche topologische Sortierung; -- Zyklen werden berücksichtigt. ” if “Zyklen gefunden” then ”Zyklen ausgeben” end 56
Allgemeine Struktur (wie vorher) class TOPOLOGISCH_SORTIERER [G ] feature auflagen : LINKED_LIST [TUPLE [G, G ]] elemente : LINKED_LIST [G ] sortiert : LINKED_LIST [G ] führe_aus require do ensure zyklus_frei (auflagen). . . kompatibel (sortiert, auflagen) end 57
Allgemeine Struktur (endgültig) class TOPOLOGISCH_SORTIERER [G ] feature auflagen : LINKED_LIST [TUPLE [G, G ]] elemente : LINKED_LIST [G ] sortiert : LINKED_LIST [G ] führe_aus require do ensure end -- Keine Vorbedingung in dieser Version. . . kompatibel (sortiert, auflagen) “sortiert enthält alle Elemente, die zu Beginn nicht in einen Zyklus involviert sind. ” end 58
Erinnerung: Die Grundidee p r q tt s v uu w topsort 59
Das grundsätzliche Schleifenschema … loop “Finde ein Element next in elemente, für das auflagen keine Paare der Form [x, next] beinhaltet sortiert. extend (next) “Lösche next aus elemente, und entferne alle Paare der Form [next, y] aus auflagen ” end 60
Die Schleifeninvariante Invariante in unserem ersten Versuch: “auflagen + enthält keine Zyklen” Invariante in der verbesserten Architektur: “auflagen + enthält keine Zyklen, die nicht ursprünglich schon enthalten waren” Allgemeiner: auflagen + ist eine Teilmenge des ursprünglichen auflagen + 61
Terminologie Falls auflagen ein Paar [x, y ], beinhaltet, sagen wir Ø x ist ein Vorfahre von y Ø y ist ein Nachfolger von x 62
Das Schema des Algoritmus führe_aus do from . create {. . . } sortiert make invariant ”auflagen enthält nur ursprüngliche Zyklen” and ”sortiert ist kompatibel mit auflagen” and ”Alle ursprünglichen Elemente sind in sortiert oder elemente” until Jedes Element von elemente hat einen Vorfahren” loop next : = “Ein Element von elemente ohne Vorfahren” sortiert extend (next ) ”Lösche next aus elemente ” ”Lösche alle Paare [next, y] aus auflagen ” variant “Grösse von elemente” end if “Keine Elemente übrig” then ”Berichte, dass das topologische Sortieren abgeschlossen ist” else ”Melde Zyklen in den übrigen auflagen und elemente” end 63
Den Algorithmus implementieren Wir beginnen mit diesen Datenstrukturen, die den Input direkt widerspiegeln: (Anzahl Elemente: n Anzahl Bedingungen: m) elemente : LINKED_LIST [G ] auflagen : LINKED_LIST [TUPLE [G, G ]] y 2 d b 1 elemente = {a, b, c, d } a 0 Beispiel: auflagen = 1 2 3 c {[a, b], [a, d ], [b, d ], [c, d ]} 64
Datenstrukturen 1: ursprünglich elemente = {a, b, c, d } auflagen = {[a, b], [a, d ], [b, d ], [c, d ]} elemente a c b d n Elemente auflagen a b a d b d c d m Bedingungen Effizienz: Das Beste, das wir uns erhoffen können, ist: O (m + n) 65
Grundoperationen führe_aus do from . create {. . . } sortiert make invariant ”auflagen enthält nur ursprüngliche Zyklen” and ”sortiert ist kompatibel mit auflagen” and ”Alle ursprünglichen Elemente sind in sortiert oder elemente” until Jedes Element von elemente hat einen Vorfahren” loop next : = “Ein Element von elemente ohne Vorfahren” sortiert extend (next ) ”Lösche next aus elemente ” ”Lösche alle Paare [next, y] aus auflagen ” variant “Grösse von elemente” end if “Keine Elemente übrig” then ”Berichte, dass das topologische Sortieren abgeschlossen ist” else ”Melde Zyklen in den übrigen auflagen und elemente” end 66
Die Operationen, die wir brauchen (n mal) Ø Herausfinden, ob es ein Element ohne Vorfahren gibt. (Und dann eines davon nehmen. ) Ø Ein gegebenes Element von der Menge der Elemente entfernen. Ø Alle Bedingungen, die mit einem gegebenen Element beginnen, aus der Menge der Bedingungen entfernen. Ø Herausfinden, ob noch ein Element vorhanden ist. 67
Effizienz Das Beste, das wir uns erhoffen können O (m + n) (da wir jede Bedingung und jedes Element mindestens einmal betrachten müssen) 68
Grundoperationen führe_aus do n mal m mal end from . create {. . . } sortiert make invariant ”auflagen enthält nur ursprüngliche Zyklen” and ”sortiert ist kompatibel mit auflagen” and ”Alle ursprünglichen Elemente sind in sortiert oder elemente” until n mal Jedes Element von elemente hat einen Vorfahren” loop next : = “Ein Element von elemente ohne Vorfahren” sortiert extend (next ) ”Lösche next aus elemente ” ”Lösche alle Paare [next, y] aus auflagen ” variant n mal “Grösse von elemente” end if “Keine Elemente übrig” then ”Berichte, dass das topologische Sortieren abgeschlossen ist” else ”Melde Zyklen in den übrigen auflagen und elemente” end . 69
Datenstrukturen 1: ursprünglich elemente = {a, b, c, d } auflagen = {[a, b], [a, d ], [b, d ], [c, d ]} elemente a c b d n Elemente auflagen a b a d b d c d m Bedingungen Effizienz: Das Beste, das wir uns erhoffen können: Wenn wir elemente und auflagen wie gegeben verwenden, können wir O (m + n) nicht erreichen! 70
Grundoperationen führe_aus do n mal m mal end from . create {. . . } sortiert make invariant ”auflagen enthält nur ursprüngliche Zyklen” and ”sortiert ist kompatibel mit auflagen” and ”Alle ursprünglichen Elemente sind in sortiert oder elemente” until n mal Jedes Element von elemente hat einen Vorfahren” loop next : = “Ein Element von elemente ohne Vorfahren” sortiert extend (next ) ”Lösche next aus elemente ” ”Lösche alle Paare [next, y] aus auflagen ” variant n mal “Grösse von elemente” end if “Keine Elemente übrig” then ”Berichte, dass das topologische Sortieren abgeschlossen ist” else ”Melde Zyklen in den übrigen auflagen und elemente” end . 71
Den Algorithmus implementieren Eine bessere interne Repräsentation wählen Jedes Element hat eine Nummer (Dies erlaubt uns, Arrays zu benutzen) Ø Wir repräsentieren auflagen in einer Form, die dem entspricht, was wir von der Struktur wollen: Ø § “Finde next , so dass auflagen kein Paar der Form [y, next ] beinhaltet. ” § “Gegeben next , lösche alle Paare der Form [next, y ] aus auflagen. 72
Schema des Algorithmus (ohne Invariante und Variante) führe_aus do from create {. . . } sortiert make until . “ Jedes Element von elemente hat einen Vorfahren” loop next : = “Ein Element von elemente ohne Vorfahren” sortiert extend (next ) ”Lösche next aus elemente ” ”Lösche alle Paare [next, y] aus auflagen ” end if “Keine Elemente übrig” then ”Berichte, dass das topologische Sortieren abgeschlossen ist” else ”Melde Zyklen in den übrigen auflagen und elemente” end 73
Datenstruktur 1: elemente repräsentieren elemente : ARRAY [G ] -- (Ersetzt die ursprüngliche Liste) 4 3 2 1 d c b a elemente = {a, b, c, d } auflagen = {[a, b], [a, d], [b, d], [c, d ]} 74
Datenstruktur 2: auflagen repräsentieren nachfolger : ARRAY [LINKED_LIST [INTEGER]] -- Elemente, die nach einem bestimmten Element -- vorkommen müssen. 4 3 4 2 4 1 2 4 nachfolger elemente = {a, b, c, d } auflagen = {[a, b], [a, d], [b, d], [c, d ]} 75
Datenstruktur 3: auflagen repräsentieren vorfahren_zahl : ARRAY [INTEGER] -- Anzahl der Elemente, die vor einem bestimmten -- Element vorkommen müssen. 4 3 3 0 2 1 1 0 vorfahren_zahl elemente = {a, b, c, d } auflagen = {[a, b], [a, d], [b, d], [c, d ]} 76
Die Grundidee (nochmals) p r q tt s v uu w topsort 77
Einen „Kandidaten“ finden (Element ohne Vorfahren) führe_aus do from create {. . . } sortiert make until . “ Jedes Element von elemente hat einen Vorfahren” loop next : = “Ein Element von elemente ohne Vorfahren” sortiert extend (next ) ”Lösche next aus elemente ” ”Lösche alle Paare [next, y] aus auflagen ” end if “Keine Elemente übrig” then ”Berichte, dass das topologische Sortieren abgeschlossen ist” else ”Melde Zyklen in den übrigen auflagen und elemente” end 78
Einen Kandidaten finden (1) Wir implementieren next : = “Ein Element von elemente ohne Vorfahren“ als: Sei next ein noch nicht abgearbeiteter Integer, so dass vorfahren_zahl [next ] = 0 Dies benötigt O (n) zum Suchen durch alle Indices: schlecht! Aber Moment. . . 79
Nachfolger löschen führe_aus do from create {. . . } sortiert make until . loop end “ Jedes Element von elemente hat einen Vorfahren” next : = “Ein Element von elemente ohne Vorfahren” sortiert extend (next ) ”Lösche next aus elemente ” ”Lösche alle Paare [next, y] aus auflagen ” . if “Keine Elemente übrig” then ”Berichte, dass das topologische Sortieren abgeschlossen ist” else ”Melde Zyklen in den übrigen auflagen und elemente” end 80
Nachfolger löschen Wir implementieren vorfahren_zahl 3 0 1 0 Implement “Lösche alle Paare [next, y] aus auflagen” “Remove from auflagen all pairs [next, y]” als Schleife über alle Nachfolger von next : as a loop over the nachfolger of next : ziele : = nachfolger [next ] from ziele start until . . nachfolger 4 3 2 1 4 3 4 2 4 1 2 ziele after loop x : = ziele. item vorfahren_zahl [x ] : = vorfahren_zahl [x ] − 1 4 . end . ziele forth 81
Nachfolger löschen vorfahren_zahl 3 0 10 0 Implement “Remove from auflagen all pairs [next, y]”nachfolger as a loop over the nachfolger of next : 4 . . end 2 1 2 4 ziele. after loop x : = ziele item vorfahren_zahl [x ] : = vorfahren_zahl [x ] − 1 . 3 4 3 ziele : = nachfolger [next ] from ziele start until 4 x . ziele forth 82
Nachfolger löschen vorfahren_zahl 32 0 10 0 Implement “Remove from auflagen all pairs [next, y]”nachfolger as a loop over the nachfolger of next : 4 . . 2 4 1 2 ziele. after loop x : = ziele. item vorfahren_zahl [x ] : = vorfahren_zahl [x ] − 1 . end 3 2 1 4 3 ziele : = nachfolger [next ] from ziele. start until 4 4 x . ziele. forth 83
Nachfolger löschen vorfahren_zahl 3 21 0 10 0 Implement “Remove from auflagen all pairs [next, y]”nachfolger as a loop over the nachfolger of next : 4 3 ziele : = nachfolger [next ] from ziele. start until . . 3 2 1 4 2 4 1 2 ziele. after loop x : = ziele. item vorfahren_zahl [x ] : = vorfahren_zahl [x ] − 1 4 4 . end . ziele. forth 84
Nachfolger löschen vorfahren_zahl 3 21 0 0 10 0 Implement “Remove from auflagen all pairs [next, y]”nachfolger as a loop over the nachfolger of next : 4 3 ziele : = nachfolger [next ] from ziele. start until . . 3 2 1 4 2 4 1 2 ziele. after loop x : = ziele. item vorfahren_zahl [x ] : = vorfahren_zahl [x ] − 1 4 4 . end . ziele. forth 85
Schema des Algorithmus führe_aus do from create {. . . } sortiert make until . loop end “ Jedes Element von elemente hat einen Vorfahren” next : = “Ein Element von elemente ohne Vorfahren” sortiert extend (next ) ”Lösche next aus elemente ” ”Lösche alle Paare [next, y] aus auflagen ” . if “Keine Elemente übrig” then ”Berichte, dass das topologische Sortieren abgeschlossen ist” else ”Melde Zyklen in den übrigen auflagen und elemente” end 86
Einen Kandidaten finden (1) Wir implementieren next : = “Ein Element von elemente ohne Vorfahre“ als: Sei next ein noch nicht abgearbeiteter Integer, so dass vorfahren_zahl [next ] = 0 Wir haben gesagt: Ø “Es scheint O (n) zu benötigen, um durch alle Indizes zu iterieren, aber Moment mal…“ 87
Nachfolger löschen vorfahren_zahl Implement 3 0 10 0 “Remove from auflagen all pairs [next, y]” nachfolger as a loop over the nachfolger of next : 4 ziele : = nachfolger [next ] from ziele start until . . 3 2 ziele after 1 loop x : = ziele item vorfahren_zahl [x ] : = vorfahren_zahl [x ] − 1 . end 4 3 2 1 4 4 ziele 2 4 . ziele. forth 88
Einen Kandidaten finden (2): auf der Stelle Wir ergänzen vorfahren_zahl [x ] : = vorfahren_zahl [x ] − 1 mit: if vorfahren_zahl [x ] = 0 then -- Wir haben einen Kandidaten gefunden! kandidaten put (x ) . end 89
Datenstrukturen 4: Kandidaten kandidaten : STACK [INTEGER ] -- Elemente ohne Vorfahren put kandidaten item, remove Anstelle eines Stapels kann kandidaten auch eine andere Dispenser-Datenstruktur sein, z. B. ein Warteschlange Die Wahl wird bestimmen, welche topologische Sortierung wir erhalten, falls es mehrere Möglichkeiten gibt. 90
Schema des Algorithmus führe_aus do from create {. . . } sortiert make until . loop end “ Jedes Element von elemente hat einen Vorfahren” next : = “Ein Element von elemente ohne Vorfahren” sortiert extend (next ) ”Lösche next aus elemente ” ”Lösche alle Paare [next, y] aus auflagen ” . if “Keine Elemente übrig” then ”Berichte, dass das topologische Sortieren abgeschlossen ist” else ”Melde Zyklen in den übrigen auflagen undelemente. ” end 91
Einen Kandidaten finden (2) Wir implementieren next : = “Ein Element von elemente ohne Vorfahren” falls kandidaten nicht leer ist, als: . next : = kandidaten item 92
Schema des Algorithmus führe_aus do from create {. . . } sortiert make until . loop end “ Jedes Element von elemente hat einen Vorfahren” next : = “Ein Element von elemente ohne Vorfahren” sortiert extend (next ) ”Lösche next aus elemente ” ”Lösche alle Paare [next, y] aus auflagen ” . if “Keine Elemente übrig” then ”Berichte, dass das topologische Sortieren abgeschlossen ist” else ”Melde Zyklen in den übrigen auflagen und elemente” end 93
Einen Kandidaten finden (3) Wir implementieren die Abfrage Jedes Element von elemente hat einen Vorfahren als not kandidaten. is_empty Um die Abfrage “Keine Elemente übrig” zu implementieren, merken wir uns die Anzahl der abgearbeiteten Elemente und vergleichen diese am Ende mit der ursprünglichen Anzahl Elemente 94
Erinnerung: die benötigten Operationen (n mal) Ø Herausfinden, ob es ein Element ohne Vorfahren gibt. (Und dann eines davon nehmen. ) Ø Ein gegebenes Element von der Menge der Elemente entfernen. Ø Alle Bedingungen, die mit einem gegebenen Element beginnen, aus der Menge der Bedingungen entfernen. Ø Herausfinden, ob noch ein Element vorhanden ist. 95
Zyklen detektieren führe_aus do from create {. . . } sortiert make until . loop end “ Jedes Element von elemente hat einen Vorfahren” next : = “Ein Element von elemente ohne Vorfahren” sortiert extend (next ) ”Lösche next aus elemente ” ”Lösche alle Paare [next, y] aus auflagen ” . if “Keine Elemente übrig” then ”Berichte, dass das topologische Sortieren abgeschlossen ist” else ”Melde Zyklen in den übrigen auflagen und elemente” end 96
Zyklen detektieren Um die Abfrage “Keine Elemente übrig” zu implementieren, merken wir uns die Anzahl der abgearbeiteten Elemente und vergleichen diese am Ende mit der ursprünglichen Anzahl Elemente. 97
Datenstrukturen: Zusammenfassung elemente : ARRAY [G ] -- Elemente, Ordnung abhängig -- von Bedingungen -- (Ersetzt die ursprüngliche Liste) 4 4 3 2 4 1 2 nachfolger : ARRAY [LINKED_LIST [INTEGER]] -- Elemente, die nach einem bestimmten Element -- vorkommen müssen vorfahren_zahl : ARRAY [INTEGER] -- Anzahl Elemente, die vor einem -- bestimmten Element vorkommen müssen 4 3 2 1 d c b a 4 3 2 1 4 2 0 1 0 kandidaten : STACK [INTEGER] -- Elemente ohne Vorfahren 98
Initialisierung Alle Elemente und alle Bedingungen müssen abgearbeitet werden, um diese Datenstrukturen zu erzeugen. Dies ist O (m + n). Dies gilt auch für den restlichen Algorithmus. 99
Datenstrukturen 1: ursprünglich elemente = {a, b, c, d } auflagen = {[a, b], [a, d ], [b, d ], [c, d ]} elemente a c b d n Elemente auflagen a b a d b d c d m Bedingungen Effizienz: Das Beste, das wir uns erhoffen können: Wenn wir elemente und auflagen wie gegeben verwenden, können wir O (m + n) nicht erreichen! 100
Datenstrukturen 2 4 elemente : ARRAY [G ] -- Elemente, Ordnung abhängig -- von Bedingungen -- (Ersetzt die ursprüngliche Liste) 4 3 nachfolger : ARRAY [LINKED_LIST [INTEGER]] -- Elemente, die nach einem bestimmten Element -- vorkommen müssen 4 vorfahren_zahl : ARRAY [INTEGER] 3 -- Anzahl Elemente, die vor einem -- bestimmten Element vorkommen müssen 2 1 d c b a 2 4 1 2 4 3 2 1 4 2 0 1 0 kandidaten : STACK [INTEGER] -- Elemente ohne Vorfahren 101
Programmübersetzung: eine nützliche Heuristik. Die Datenstruktur ist, so wie sie gegeben ist, meist nicht die geeignetste für einen spezifischen Algorithmus. Um einen effizienten Algorithmus zu erhalten, müssen wir sie in eine speziell geeignete Form bringen. Wir können dies “übersetzen” der Daten nennen. Oft ist diese „Übersetzung“ (Initialisierung) genauso teuer wie das wirkliche Abarbeiten, manchmal sogar noch teurer. Aber dies stellt kein Problem dar, falls es die Gesamtkosten reduziert. 102
Eine weitere Lektion Es kann durchaus OK sein, Informationen in unseren Datenstrukturen zu duplizieren Ursprüngliche Datensgtrukturen: ohne duplizierten Information elemente a c b d n Elemente auflagen a b a d b d c d m Bedingungen 103
Datenstrukturen: mit duplizierter Information elemente : ARRAY [G ] -- Elemente, Ordnung abhängig von Bedingungen -- (Ersetzt die ursprüngliche Liste) nachfolger : ARRAY [LINKED_LIST [INTEGER]] -- Elemente, die nach einem -- bestimmten Element vorkommen müssen vorfahren_zahl : ARRAY [INTEGER] 4 -- Anzahl Elemente, die vor einem 3 -- bestimmten Element vorkommen müssen 2 kandidaten : STACK [INTEGER] -- Elemente ohne Vorfahren 1 4 4 3 2 4 1 2 4 3 d c b a 2 1 4 2 0 104
Schlüsselkonzepte Ø Ø Ø Ø Ein sehr interessanter Algorithmus, der für verschiedenste Anwendungen nützlich ist. Mathematische Basis: Binäre Relationen Transitive Hülle, reflexive transitive Hülle Algorithmus: Datenstrukturen anpassen ist der Schlüssel zum Erfolg “Übersetzungs”strategie Initialisierung kann genauso teuer sein wie das eigentliche Abarbeiten Der Algorithmus ist nicht genug: Wie brauchen ein API (praktisch, erweiterbar, wiederverwertbar) Dies ist der Unterschied zwischen Algorithmen und Software-Engineering 105
Lektion in Sachen Software-Engineering Gute Algorithmen sind nicht genug. Wir müssen eine Lösung mit einer klaren Schnittstelle (API) zur Verfügung stellen, die einfach zu benutzen ist. Muster (Patterns) in Komponenten überführen. 106
- Die mier en die sprinkaan pdf
- Programmdokumentation beispiel
- Funktionale vs objektorientierte programmierung
- Funktionale programmierung tu dortmund
- Fischertechnik robo pro programmierung
- Logische programmierung beispiel
- Java gui tutorial
- Gui event handling
- Programmierung
- Strukturierte programmierung beispiel
- Grundidee objektorientierte programmierung
- Programmierung polymorphie
- Java gui programmierung
- Calliope.cc
- Hochschule fulda ai
- Funktionale programmierung tum
- Strukturierte programmierung
- Objektorientierte programmierung
- Java swing libraries
- What is system in software engineering
- Forward engineering and reverse engineering
- Software maintenance process models ppt
- Who invented software engineering
- What is software metrics in software engineering
- Example of software crisis
- Software measurement and metrics
- Real time software design in software engineering
- Software design fundamentals in software engineering
- Die kinder verbringen die ferien
- Je höher die berge desto schöner die gams
- Lewensdoelwitte
- Hippies kenmerken
- Die einde van die koue oorlog 1989
- Ek glo in god die vader
- Pad van waarheid tot die lewe
- Lydende vorm
- 2folie
- Jys die stem in die stilte wat agterbly
- Rosen die ich an dich verschenke
- De druppel die de emmer doet overlopen
- Die vorhaut ist die haut spruch
- Pad van waarheid en lewe
- Pad van waarheid tot die lewe
- Voegwoorde graad 6
- Dicapine
- Elegant systems
- Forward and reverse engineering
- Pencil a or an
- Two chair dialogue
- Barany chair
- Stereochemistry of alkanes and cycloalkanes
- Moon rhyming word
- Red white and blue chair
- 1 point perspective room
- Hazard
- Volailles à chair blanche
- Design on cup
- John purdy inventor
- Brute force chair
- Gestalt empty chair
- Empty chair technique worksheet
- How to draw chair conformations
- Picasso’s still life with chair caning
- Picasso’s still life with chair caning
- Is biscuits countable or uncountable
- Alkane vs alkene
- Tetrahydropyran chair conformation
- Dilbert chair safety training
- Operator chair position dentistry
- Wilson's moral diplomacy definition
- Still light tunic описание на русском
- It's a _________pencil
- Honorable audience
- Xxxchair
- Chair sit and reach test
- Vestibular autorotation test
- 10 minute chair yoga for seniors
- Paroles fais nous marcher à ta lumière
- Porridge
- Abiotic and biotic
- Gambrel roof interior design
- Cvpr borderline
- Potts elevator technique
- Emis chair
- Jmason high chair
- Transcribe hair
- Club foundation chair
- Neelam chair
- Frederick j loudin keychain invention
- Knowledge chair
- Site:slidetodoc.com
- There are books in chair
- Which describes antony’s tone when speaking to octavius?
- Rail fixtures and fastenings
- Dicle the pony
- Cozzia 16018 massage chair
- Main submitter speech mun example
- Meat joy
- How to draw isomtric freehnad
- Confluence gestalt
- Stretcher lift first aid
- Bob ics chair
- One and three chairs
- Simple compound words
- My toy cars am is are in the box
- Haines chair
- Jmason high chair