diff --git a/.gitignore b/.gitignore
index 3c3629e647f5ddf82548912e337bea9826b434af..6aa071b24c2fddfd7066c74f8dc51e23c4b905af 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,4 @@
node_modules
+package-lock.json
+.parcel-cache
+build
diff --git a/dataset.js b/dataset.js
index 7a348bf07cb76511930d35ea5c925932e54c98ec..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644
--- a/dataset.js
+++ b/dataset.js
@@ -1 +0,0 @@
-const PLUGIN_PATH = "http://localhost/2021/aud_worpress/wp-content/plugins/knowledge-space-wp-plugin/";
\ No newline at end of file
diff --git a/datasets/AuD-Inhalt2.xlsx b/datasets/AuD-Inhalt2.xlsx
new file mode 100644
index 0000000000000000000000000000000000000000..f07e70394ee951ef64e6d85268e7c24c7d972066
Binary files /dev/null and b/datasets/AuD-Inhalt2.xlsx differ
diff --git a/datasets/aud1v2.json b/datasets/aud1v2.json
index 98905462a596f63b0c2aad1743188d6a149805e8..bba5f29fcfcb5b49433e618cd7727438773cd7ec 100644
--- a/datasets/aud1v2.json
+++ b/datasets/aud1v2.json
@@ -1,1431 +1,730 @@
{
- "nodes": [
- {
- "id": 1,
- "name": "Einführung",
- "description": "Eine Einführung in die Algorithmen und Datenstrukturen\n+ Links zu Video und Folien"
- },
- {
- "id": 2,
- "name": "Rundreise Problem",
- "description": "Gegeben: Ein Graph G = (V, E) mit Kantenlängen we, Gesucht: Eine kürzeste Rundreise, welche alle Knoten im Graphen einmal besucht und im Startknoten wieder endet."
- },
- {
- "id": 3,
- "name": "Puzzle",
- "description": "Jeder hat schon einmal ein Puzzle gelöst, doch wie sieht das aus algorithmischer Sicht aus?"
- },
- {
- "id": 4,
- "name": "Algorithmus-Definition",
- "description": "“Ein Algorithmus ist eine aus endlich vielen Schritten bestehende eindeutige Handlungsvorschrift zur Lösung eines Problems oder einer Klasse von Problemen.â€-Wikipedia. Dabei wird als Input eine Problembeschreibung gegeben und durch Anwendung des Algorithmus eine fertige Lösung des Problems ermittelt. Oft spielt die Laufzeit des Algorithmus eine große Rolle. Sie beschreibt, wie viele einzelne Schritte nötig sind um das Problem zu lösen, in Abhängigkeit von der Größe des Problems."
- },
- {
- "id": 5,
- "name": "Kofferpacken",
- "description": "Kann ich alle meine Gepäckstücke auf zwei gleich große Koffer aufteilen? Gegeben: Eine Menge von n Objekten, jedes mit\neiner Größe li; Gesamtgröße ∑ li = 2K\nGesucht: Eine Verteilung auf zwei Koffer der Größe K"
- },
- {
- "id": 6,
- "name": "P und NP",
- "description": "Die Klassen P und NP teilen algorithmische Probleme in zwei Kategorien auf. Die eine, bei der man mithilfe eines Algorithmus eine Lösung Pfinden kann (P) und eine zweite, bei der bisher nur das NachPrüfen einer existierenden Lösung gelingt (NP). Wenn es allerdings keine Lösung gibt, so lässt sich das bei Problemen der Klasse NP nur schlecht beweisen."
- },
- {
- "id": 7,
- "name": "Algorithmen und Datenstrukturen",
- "description": "In dieser Vorlesung wird der Begriff 'Algorithmus' definiert und erklärt.\n+ Links zu Video und Folien"
- },
- {
- "id": 8,
- "name": "Datenstrukturen",
- "description": "Eine Datenstruktur erlaubt es, die für eine Aufgabe notwendigen Informationen geeignet zu repräsentieren und den Zugriff und die Verwaltung während der Bearbeitung in effizienter Weise zu ermöglichen."
- },
- {
- "id": 21,
- "name": "Organisation und Pseudocode",
- "description": "In dieser Ãœbung haben wir noch einmal organisatorische Dinge besprochen und uns mit dem Thema Pseudocode auseinandergesetzt.\n+ Links zu Video und Folien"
- },
- {
- "id": 9,
- "name": "Pseudocode",
- "description": "Pseudocode ist eine Art Algorithmen einigermaßen einheitlich zu notieren. Dabei werden zwar Schlüsselwörter genutzt um eine gewisse Einheitlichkeit zu bieten und gleichzeitig die Logik zu beschreiben, allerdings geht es noch nicht darum einen compilierbaren Code mit korrekter Syntax zu schreiben.\n+ Link zu Pseudocodeblatt, Übung 1"
- },
- {
- "id": 10,
- "name": "Graphen",
- "description": "Eine Einleitung in die Welt der Graphen am wohl bekanntesten Beispiel, dem Haus des Nikolaus.\n+ Links zu Video und Folien"
- },
- {
- "id": 11,
- "name": "Haus des Nikolaus",
- "description": "Jeder kennt das Haus vom Nikolaus, doch wie wird es gemalt? Wo setzt man den Stift an und wo wieder ab?"
- },
- {
- "id": 12,
- "name": "Eulertouren",
- "description": "Ein Eulerweg ist ein Weg in einem Graphen, welcher alle Kanten nutzt. Eine Eulertour kehrt darüber hinaus auch zum Startknoten zurück."
- },
- {
- "id": 13,
- "name": "Graphenbegriffe",
- "description": "Ein Graph besteht aus Knoten und Kanten das sollte inzwischen jeder wissen, doch was parallele Kanten, Schleifen, (geschlossene) Wege, Pfade, Kreise, Eulerwege/-touren, sowie Hamiltonpfade und -kreise sind wird in dieser Vorlesung noch einmal genau definiert.\n+ Links zu Video und Folien"
- },
- {
- "id": 14,
- "name": "Graph",
- "description": "Über Graphen haben wir bereits viel gesprochen, doch was ein Graph genau ist und wie man ihn definiert erfährst du hier."
- },
- {
- "id": 15,
- "name": "Wege in Graphen",
- "description": "Eine Kantenfolge W in einem Graphen G heißt Weg, wenn sich keine Kante darin wiederholt und geschlossener Weg (Tour), wenn man am Ende wieder am Startknoten ankommt. Wiederholt sich kein Knoten spricht man von einem Pfad. Ein Kreis ist ein geschlossener Pfad. Bei einem Eulerweg/ einer Eulertour werden alle Kanten des Graphen genutzt. Ein Hamiltonpfad/kreis nutzt hingegen alle Knoten."
- },
- {
- "id": 16,
- "name": "Beweistechniken",
- "description": "In der Mathematik und auch in der Algorithmik spielen Beweise immer wieder eine große Rolle. Es geht darum Aussagen zu belegen, zu widerlegen oder auf bestimmte Elemente anzuwenden. Dazu gibt es verschiedene Beweistechniken, welche ihr hier finden könnt:\n+ Link zu Beweisblatt, Übung 2"
- },
- {
- "id": 17,
- "name": "Eulertouren",
- "description": "In dieser Vorlesung werden notwendige Bedingungen für Eulertouren erleutert. Zusätzlich wird das Kapitel 2 noch einmal zusammengefasst und es werden Algorithmen eingeführt um die uns bisher bekannten Probleme zu lösen.\n+ Links zu Video und Folien"
- },
- {
- "id": 18,
- "name": "Algorithmus Wegfindung",
- "description": "Dieser Algorithmus (2.7) erhält als Input einen Graphen G mit höchstens zwei ungeraden Knoten und liefert als Output einen Weg in G"
- },
- {
- "id": 19,
- "name": "Algorithmus von Hierholzer",
- "description": "Dieser Algorithmus (2.8) erhält als Input einen zusammenhängenden Graphen G mit höchstens zwei ungeraden Knoten und liefert als Output einen Eulerweg, bzw. eine Eulertour in G. Dazu wird auch Algorithmus 2.7 zum Finden von Wegen in G verwendet."
- },
- {
- "id": 20,
- "name": "Algorithmus von Fleury",
- "description": "Dieser Algorithmus(2.13) erhält als Input einen Graphen G mit höchstens 2 ungeraden Knoten und liefert als Output einen Weg in G. Der Algorithmus hat als Grundlage Algorithmus 2.7 zum Finden von Wegen. Auch lässt sich zeigen, dass man mit diesem Algorithmus eine Eulertour/einen Eulerweg finden kann"
- },
- {
- "id": 22,
- "name": "Anwendung von Graphen",
- "description": "In dieser Vorlesung geht es um den Einsatzzweck von Graphen und es wird am Beispiel der Erdös- und der Kevin Bacon Zahl gezeigt, welche Zusammenhänge dargestellt werden können.\n+ Links zu Video und Folien"
- },
- {
- "id": 23,
- "name": "Beweistechniken Teil 2",
- "description": "In dieser Übung geht es um die Beweistechnik der vollständigen Induktion. Diese ist die wohl meist benutzte Beweistechnik in der Algorithmik. Auch werden Anwendungsbeispiele wie z.B. die Gauß'sche Summenformel oder der Zusammenhang in Graphen erläutert.\n+ Links zu Video und Folien/Notizen"
- },
- {
- "id": 24,
- "name": "Graphenscan",
- "description": "In dieser Vorlesung wird der Graphenscanalgorithmus vorgestellt um Zusammenhangskomponenten in Graphen zu finden.\n+ Links zu Video und Folien/Notizen/Beweis"
- },
- {
- "id": 25,
- "name": "Algorithmus Graphenscan",
- "description": "Dieser Algorithmus (3.7) erhählt als Input einen Graphen G = (V,E) und einen Knoten s darin und liefert als Output eine Knotenmenge Y aus V, die von s aus erreichbar ist, sowie eine Kantenmenge T aus E, welche die Erreichbarkeit sicherstellt"
- },
- {
- "id": 26,
- "name": "Datenstrukturen Teil 1",
- "description": "In dieser Vorlesung werden die Datenstrukturen Warteschlange (First In - First Out) und Stapel (Last In - First Out) vorgestellt. Außerdem geht es um ihre Rolle für Algorithmen und wie man sie implementieren kann. Das ganze wird am Beispiel des Graphscan Algorithmus gezeigt und somit werden auch Breiten- und Tiefensuche eingeführt.\n+ Links zu Video und Folien/Beispiel"
- },
- {
- "id": 27,
- "name": "Warteschlange",
- "description": "Eine Warteschlange ist eine Datenstruktur, welche nach dem Prinzip 'First In - First Out' arbeitet. Man findet sie auch im alltäglichen Leben oft wieder, wenn man sich beispielsweise an der Kasse anstellen muss. Der Kunde der zuerst da war, wir auch zuerst bedient."
- },
- {
- "id": 28,
- "name": "Stapel",
- "description": "Ein Stapel ist eine Datenstruktur, welche nach dem Prinzip 'Last In - First Out' arbeitet. Im alltäglichen Leben findet man diese Form der Datenstruktur beim Geschirr abwaschen, man stapelt die Teller und der Teller der zuletzt dreckig wurde wird als erstes gereinigt, da man die Teller von oben herunter nimmt."
- },
- {
- "id": 29,
- "name": "Breitensuche",
- "description": "Die Breitensuche ist im Prinzip der Graphscan Algorithmus, ausgeführt mithilfe einer Warteschlange als Datenstruktur. Sie breitet sich aus wie eine Welle."
- },
- {
- "id": 30,
- "name": "Tiefensuche",
- "description": "Die Breitensuche ist im Prinzip der Graphscan Algorithmus, ausgeführt mithilfe eines Stapels als Datenstruktur. Dabei werden eher einzelne Pfade gelaufen."
- },
- {
- "id": 31,
- "name": "Datenstrukturen Teil 2",
- "description": "In dieser Vorlesung geht es einerseits um die Anwendung der Breitensuche, andererseits werden noch 2 weitere Datenstrukturen eingeführt: Die Inzidenz/-Adjazenzmatrix, sowie die Kantenliste\n+ Links zu Video und Folien/Notizen"
- },
- {
- "id": 32,
- "name": "Inzidenz/-Adjazenzmatrix",
- "description": "In einer Inzidenzmatrix wird mithilfe von 1en und 0en dargestellt, welche Knoten mit welchen Kanten inzident (zusammentreffend) sind. Bei einer Adjazenzmatrix wird dargestellt, welche Knoten adjazent (durch eine Kante verbunden) sind."
- },
- {
- "id": 33,
- "name": "Kanten-/Adjazenzliste",
- "description": "Eine Kantenliste ist eine Liste bestehend aus einträgen der Form {vx, vy}, welche bedeuten, dass eine Kante zwischen vx und vy im Graphen existiert."
- },
- {
- "id": 34,
- "name": "Wachstum/O-Notation",
- "description": "In dieser Vorlesung wird noch einmal mit den Adjazenz- und Kantenlisten abgeschlossen. Außerdem schauen wir uns einmal das Wachstum von Funktionen an und definieren und die O-Notation um damit zu arbeiten.\n+ Links zu Video und Folien/Notizen"
- },
- {
- "id": 35,
- "name": "O-Notation",
- "description": "Die O-Notation wird genutzt um das Wachstum von Funktionen abzuschätzen. Damit können Größenordnungen und Wachstumsverhalten beschrieben werden."
- },
- {
- "id": 36,
- "name": "Graphscan Ãœbung",
- "description": "Simple Anwengung des Graphscan Algorithmus, einmal als Breiten- und als Tiefensuche. Wann welcher Algorithmus besser geeignet ist wird in dieser Übung erklärt."
- },
- {
- "id": 37,
- "name": "Wachstum",
- "description": "Die O-Notation wird genutzt um das Wachstum von Funktionen abzuschätzen. In dieser Übung werden Zusammenhänge zwischen der Größe des Inputs und dem Wachstum, sowie Relationen zwischen Laufzeitklassen näher beleuchtet. Auch wird die O-Notation an verschiedenen Beispielen erklärt."
- },
- {
- "id": 38,
- "name": "Wiederholung oder\nSuche in Graphen Zusammenfassung",
- "description": "Noch einmal ein Rückblick auf alles, was bisher in 'Kapitel 3: Suche in Graphen' passiert ist. \n+ Links zu Video und Folien"
- },
- {
- "id": 39,
- "name": "Eigenschaften von DFS und BFS",
- "description": "In dieser Vorlesung betrachten wir die Breiten- und Tiefensuche im Hinblick auf ihre Laufzeit. Dabei wird anschaulich, wie die Algorithmen arbeiten, wann man sie am besten nutzen sollte und wie man Laufzeiten beweisen kann.\n+ Links zu Video und Folien/Notizen"
- },
- {
- "id": 40,
- "name": "Induktionsbeweise Bsp.",
- "description": "Einige Beispiele, bei denen der Induktionsbeweis auch in der Graphentheorie zum Einsatz kommt. "
- },
- {
- "id": 41,
- "name": "Adjazenzliste",
- "description": "Wie eine Adjazenzliste für einen Graphen erstellt werden kann wird hier einmal genauer beleuchtet."
- },
- {
- "id": 42,
- "name": "Graphscan Beispiel",
- "description": "Hier wird der Graphscan Algorithmus einmal mithilfe einer Adjazenzliste als Datenstruktur durchgeführt."
- },
- {
- "id": 43,
- "name": "Dynamische Datenstrukturen",
- "description": "In dieser Vorlesung beginnen wir dynamische Datenstrukturen einzuführen. Es werden Stapel, Warteschlangen und verkettete Listen vorgestellt. Außerdem beschäftigen wir uns mit binärer Suche.\n+ Links zu Video und Folien"
- },
- {
- "id": 44,
- "name": "Verkettete Liste",
- "description": "Eine verkettete Liste ist eine dynamische Datenstruktur. Dabei werden für die einzelnen Elemente jeweils Vorgänger und Nachfolger mit gespeichert. Der Vorteil hierbei ist, dass neue Einträge überall eingefügt werden können."
- },
- {
- "id": 45,
- "name": "Binäre Suche",
- "description": "Dieser Algorithmus (4.1) erhält als Input einen sortierten Array mit Einträgen S[I], Suchwert WERT, linke Randposition LINKS, rechte Randposition RECHTS und liefert als Output die Position von WERT zwischen Arraypositionen LINKS und RECHTS, falls existent."
- },
- {
- "id": 46,
- "name": "Binäre Suche Idee",
- "description": "Ein einleitendes Beispiel zur Binären Suche."
- },
- {
- "id": 47,
- "name": "Binäre Suche Beispiel",
- "description": "Der Algorithmus für die binäre Suche einmal an zwei Beispielen angewandt."
- },
- {
- "id": 48,
- "name": "Binäre Suchbäume",
- "description": "In dieser Vorlesung beschäftigen wir uns genauer mit binären Suchbäumen und den darauf anwendbaren Operationen, wie Maximum, Minimum, einfügen und löschen von Knoten, sowie mit der binären Suche.\n+ Links zu Video und Folien"
- },
- {
- "id": 49,
- "name": "Binärer Suchbaum",
- "description": "In dieser Definition werden die Begriffe 'gerichteter Graph/Baum', 'Höhe eines Baumes', '(voller/vollständiger) binärer Baum', 'Blatt eines Baumes', 'Teilbaum eines Knotens' und 'binärer Suchbaum' definiert und erklärt."
- },
- {
- "id": 50,
- "name": "Grundoperationen Suchbaum",
- "description": "Minimum/Maximum finden, Suche im Baum, Nachfolger finden, Einfügen und Löschen sind die Grundoperationen, welche auf binäre Suchbäume angewendet werden können. Und hier findet ihr die Algorithmen dazu."
- },
- {
- "id": 51,
- "name": "AVL-Bäume",
- "description": "In dieser Vorlesung beschäftigen wir uns mit speziellen binären Suchbäumen, den AVL-Bäumen und ihren Eigenschaften.\n+ Links zu Video und Folien/Notizen"
- },
- {
- "id": 52,
- "name": "AVL-Baum",
- "description": "Ein binärer Suchbaum ist höhenbalanciert, wenn sich für jeden Knoten v die Höhe der beiden Kinder von v um höchstens 1 unterscheidet. Ein höhenbalancierter Suchbaum heißt auch AVL-Baum."
- },
- {
- "id": 53,
- "name": "dyn. Operationen auf AVL-Bäumen",
- "description": "In dieser Vorlesung beschäftigen wir uns mit dem Erhalt der AVL-Eigenschaft eines binären Suchbaumes bei Einfüge- und Löschoperationen. Außerdem werfen wir einen Blick auf die Fibonacci-Zahlen.\n+ Links zu Video und Folien"
- },
- {
- "id": 54,
- "name": "AVL-Rotation",
- "description": "Dieser Algorithmus (4.9) erhält als Input einen Knoten x eines binären Suchbaumes T, Vaterknoten y, Großvaterknoten z und liefert als Output den binären Suchbaum T nach Umstrukturierung mit x, y, z."
- },
- {
- "id": 55,
- "name": "Fibonacci-Zahlen",
- "description": "Die Fibonacci-Zahlen sind eine rekursiv definierte Zahlenfolge, bei der sich eine Zahl aus der Summe ihrer zwei Vorgänger ergibt. Dabei sind die ersten beiden Elemente gegeben als 1. Die Fibonacci-Zahlen finden sich überall in der Natur wieder und haben nicht wenig mit unserer Auffassung von Schönheit zu tun."
- },
- {
- "id": 56,
- "name": "Bäume-Übung",
- "description": "In dieser Übung beschäftigen wir uns noch einmal genauer mit einigen Datenstrukturen wie verketteten Listen, binären Bäumen und AVL-Bäumen."
- },
- {
- "id": 57,
- "name": "Laufzeit von Algorithmus 2.7",
- "description": "Wir betrachten einmal die Laufzeit des Hierholzer-Algorithmus (2.7) und im Zusammenhang damit auch verkettete Listen."
- },
- {
- "id": 58,
- "name": "Grundoperationen Suchbaum",
- "description": "In diesem Teil der Übung werden einmal die Operationen Einfügen, Suchen, Vorgänger/Nachfolger finden, löschen und verschmelzen von binären Suchbäumen geübt."
- },
- {
- "id": 59,
- "name": "AVL-Baum-Operationen",
- "description": "Wir schauen uns noch einmal genauer die AVL-Bäume an und was man damit machen kann. Insbesondere auch die Operationen Löschen und Einfügen."
- },
- {
- "id": 60,
- "name": "Dynamische Datenstrukturen 2",
- "description": "In dieser Vorlesung schauen wir noch einmal auf das bisher in Kapitel 4 gelernte zurück. Außerdem geben wir einen Überblick über einige weitere dynamische Datenstrukturen wie Rot-Scharz-Bäumme, B-Bäume und Heaps.\n+ Links zu Video und Folien"
- },
- {
- "id": 61,
- "name": "Rot-Schwarz-Bäume",
- "description": "Ein binärer Suchbaum heißt Rot-Schwarz-Baum, wenn er die folgenden Eigenschaften erfüllt:\n1. Jeder Knoten ist entweder rot oder schwarz.\n2. Die Wurzel ist schwarz.\n3. Jedes Blatt (NIL) ist schwarz.\n4. Wenn ein Knoten rot ist, sind seine beiden Kinder schwarz.\n5. Für jeden Knoten enthalten alle Pfade nach unten zu einem Blatt des Teilbaumes die gleiche Anzahl schwarzer Knoten."
- },
- {
- "id": 62,
- "name": "B-Bäume",
- "description": "B-Bäume sind binäre Suchbäume, welche für externen Speicher (HDDs) optimiert sind. Dabei wird die Höhe des Baumes minimiert und es werden den Knoten mehr Schlüssel zugewiesen."
- },
- {
- "id": 63,
- "name": "Heaps",
- "description": "Ein gerichteter binärer Baum heißt binärer Min/Max-Heap, wenn jeder Knoten einen Schlüssel hat, alle Ebenen außer der 'letzten' genau 2 Knoten haben, auf der 'letzten' Ebene die linken n-(2^h)+1 Positionen besetzt sind und jeder Schlüssel eines Knotens höchstens/mindestens so groß ist wie die seiner Kinder."
- },
- {
- "id": 64,
- "name": "Sortieren",
- "description": "In dieser Vorlesung geben wir eine Einführung in das Oberthema Sortieren. Wir stellen außerdem einen Sortieralgorithmus mit dem Namen Mergesort vor und stellen grundlegende Überlegungen zur Laufzeit von Sortieralgorithmen an.\n+ Links zu Video und Folien/Notizen"
- },
- {
- "id": 65,
- "name": "Merge-Sort",
- "description": "Dieser Algorithmus (5.1) erhält als Input ein Subarray von A=[1,...,n], der bei Index p beginnt und bei Index r endet, d.h. A[p,...,r] und liefert als Output ein sortiertes Subarray. Wichtig ist dafür auch die Subroutine (5.2), welche als Input zwei sortierte Subarrays von A=[1,...,n], d.h. A[p,...,q] und A[q+1,...,r] erhält und als Output das sortierte Subarray A[p,...,r] liefert."
- },
- {
- "id": 66,
- "name": "Sortier-Laufzeitschranken",
- "description": "In dieser Vorlesung leiten wir konkrete Laufzeitschranken für das Problem des Sortierens einer Liste von Zahlen her. Zudem machen wir uns Gedanken über das Lösen von Rekursionsgleichungen.\n+ Links zu Video und Folien/Notizen"
- },
- {
- "id": 67,
- "name": "Permutation",
- "description": "Eine Permutation P ist eine Umsortierung von n Objekten."
- },
- {
- "id": 68,
- "name": "Erzeugende Funktionen",
- "description": "Erzeugende Funktionen können genutzt werden um Rekursionen zu lösen."
- },
- {
- "id": 69,
- "name": "Erzeugende Funktionen/Mastertheorem",
- "description": "In dieser Vorlesung besprechen wir weitere Details zu erzeugenden Funktionen und führen das Master-Theorem ein.\n+ Links zu Video und Folien/Notizen"
- },
- {
- "id": 70,
- "name": "erzeugende Funktionen Fibonacci-Zahlen",
- "description": "In diesem Beispiel wird einmal die erzeugende Funktion der Fibonacci-Zahlen hergeleitet."
- },
- {
- "id": 71,
- "name": "Master-Theorem",
- "description": "Das Master-Theorem bietet eine schnelle Lösung für die Frage, in welcher Laufzeitklasse eine gegebene rekursiv definierte Funktion liegt. Dies funktioniert leider nur, solange einer der drei Fälle des Theorems auf die Funktion angewandt werden kann, ansonsten liefert das Theorem keine Aussage."
- },
- {
- "id": 72,
- "name": "Master-Theorem Beispiele",
- "description": "Einige Beispiele, an denen das Master-Theorem und seine Funktion noch einmal verdeutlicht wird."
- },
- {
- "id": 73,
- "name": "Sortieralgorithmen und Master-Theorem",
- "description": "Wir betrachten ein weiteres Beispiel für Mergesort und leiten erneut die Laufzeit des Sortieralgorithmus her, indem das Master-Theorem benutzt wird. Außerdem betrachten wir einen weiteren Sortieralgorithmus: Heapsort.\n+ Links zu Video und Folien"
- },
- {
- "id": 74,
- "name": "Merge-Sort Beispiel",
- "description": "Hier wird der Merge-Sort Algorithmus einmal mit einem Beispiel komplett durchgeführt und die Laufzeit des Algorithmus betrachtet."
- },
- {
- "id": 75,
- "name": "Master-Theorem Beispiel",
- "description": "3 weitere Beispiele, welche dabei helfen das Master-Theorem zu verstehen und anzuwenden."
- },
- {
- "id": 76,
- "name": "Max-Heaps",
- "description": "Hier wir aufgezeigt, wie man mithilfe eines Algorithmus Max-Heaps bildet. "
- },
- {
- "id": 77,
- "name": "Max-Heaps",
- "description": "Hier wird der Algorithmus aus der Ãœbung 6 zum Erstellen eines Max-Heaps einmal an einem Beispiel angewandt."
- },
- {
- "id": 78,
- "name": "Heapsort",
- "description": "Heapsort ist ein Algorithmus bei dem mithilfe von Max-Heaps eine Reihe von Elementen sortiert werden kann. Der Algorithmus hat dabei eine Laufzeit von O(n log n), wie auch in Ãœbung 6 bewiesen wird."
- },
- {
- "id": 79,
- "name": "nichtlineare Rekursionen (Exkurs)",
- "description": "In dieser Vorlesung haben wir einen Exkurs in die nichtlineare Rekursion gemacht.\n+ Links zu Video und Folien"
- },
- {
- "id": 80,
- "name": "logistische Rekursion",
- "description": "Logistische Rekursion bezeichnet ein Wachstum proportional zu einer Größe. Dabei betrachtet man beispielsweise eine Bevölkerung, welche zwar durch Fruchtbarkeit immer weiter wächst, aber beispielsweise durch Tod auch wieder im Wachstum beschränkt wird."
- },
- {
- "id": 81,
- "name": "Mandelbrot-Menge",
- "description": "Die Mandelbrot-Menge, benannt nach Benoît Mandelbrot, ist die Menge der komplexen Zahlen c, für welche die durch die Iteration z_0 = 0 und z_(n+1) = ((z_n)^2) +c definierte Folge (z_n) mit n aus den natürlichen Zahlen beschränkt ist. - Wikipedia"
- },
- {
- "id": 82,
- "name": "Fraktale",
- "description": "Ein Fraktal beschreibt natürliche oder künstliche Gebilde oder geometrische Muster und ist ein von Benoît Mandelbrot geprägter Begriff. - Wikipedia"
- },
- {
- "id": 83,
- "name": "Zelluläre Automaten",
- "description": "Zelluläre oder auch zellulare Automaten dienen der Modellierung räumlich diskreter dynamischer Systeme, wobei die Entwicklung einzelner Zellen zum Zeitpunkt t+1 primär von den Zellzuständen in einer vorgegebenen Nachbarschaft und vom eigenen Zustand zum Zeitpunkt t abhängt. - Wikipedia"
- },
- {
- "id": 84,
- "name": "Game of Life",
- "description": "Das 'Game of Life' ist das wohl bekannteste Beispiel eines zellulären Automaten. "
- },
- {
- "id": 85,
- "name": "Quick-Sort",
- "description": "In dieser Vorlesung kehren wir zurück zu Sortieralgorithmen und stellen den Quicksort-Algorithmus vor.\n+ Links zu Video und Folien/Notizen"
- },
- {
- "id": 86,
- "name": "Quick-Sort",
- "description": "Dieser Algorithmus (5.14) erhält als Input ein Subarray von A=[1,...,n], der bei Index p beginnt und bei Index r endet, d.h. A[p,...,r] und liefert als Output einen sortierten Subarray. Dabei ist auch Subroutine 5.15 wichtig, welche als Input ein Subarray von A=[1,...,n], d.h. A[p,...,r] erhält und als Output zwei Subarrays A[p,...,q-1] und A[q+1,...,r] mit A[i]≤A[q] und A[q]<A[j] für i=p,...,q-1 und j=q+1,...,r liefert."
- },
- {
- "id": 87,
- "name": "Laufzeit von Quick-Sort",
- "description": "Die Laufzeit des Quick-Sort Algorithmus lässt sich mithilfe vom Master-Theorem ermitteln. Dazu betrachten wir die 3 Fälle best-case, average-case und worst-case für den Algorithmus."
- },
- {
- "id": 88,
- "name": "Mediane",
- "description": "In dieser Vorlesung beschäftigen wir uns mit Medianen.\n+ Links zu Video und Folien"
- },
- {
- "id": 89,
- "name": "Standortprobleme",
- "description": "Was ist der optimale Standort für beispielsweise ein Amazon-Lagerhaus? Idee: Die durchschnittliche Distanz zu den zu beliefernden Gebäuden minimieren. In Amerika ist dies leicht umgesetzt mit der sogenannten Manhatten-Distanz. Dieses Problem ist die Einführung in das Thema der Mediane."
- },
- {
- "id": 90,
- "name": "Median (diskret)",
- "description": "Der Rank k eines Elements x (auch 'k-tes Element') ist definiert durch |{y ∈ X |y<=x}| = k. Also die Anzahl der Elemente, welche kleiner oder gleich x sind. Speziell heißt x Median, wenn er das [n/2]-te Element ist. [n/2] wird dabei abgerundet."
- },
- {
- "id": 91,
- "name": "Median (kontinuierlich)",
- "description": "Der kontinuierliche Median hat als Eigenschaft, dass das sowohl Integral bis zum Median, als auch ab dem Median größer-gleich 1/2 ist."
- },
- {
- "id": 92,
- "name": "Sortieralgorithmen Sonderfälle",
- "description": "In dieser Vorlesung beschäftigen wir uns mit Sonderfällen für Sortieralgorithmen, durch die Sortieren in linearer Zeit ermöglicht wird. Dabei werfen wir einen näheren Blick auf die Sortierverfahren Countingsort und Radixsort.\n+ Links zu Video und Folien/Notizen"
- },
- {
- "id": 93,
- "name": "Counting-Sort",
- "description": "Dieser Algorithmus (5.14) erhält als Input ein Array von A=[1],...,A[n] mit Schlüsselwerten aus {1,…, k} und liefert als Output eine sortierte Kopie B[1],…,B[n] von [1],...,A[n]."
- },
- {
- "id": 94,
- "name": "Radix-Sort",
- "description": "Dieser Algorithmus (5.18) erhält als Input n Zahlen mit je d Ziffern, die k verschiedene Werte annehmen können, [1],...,A[n] und liefert als Output einen sortierten Array. Dabei geht Radix-Sort im Gegensatz zu anderen Sortieralgorithmen ziffernweise vor."
- },
- {
- "id": 95,
- "name": "Quick-Sort, Mediane, kd-Bäume",
- "description": "In dieser Übung schauen wir uns noch einmal das Sortierverfahren Quicksort an und sprechen über die Berechnung von Medianen. Außerdem schauen wir uns mit den kd-Bäumen eine spezielle Datenstruktur für mehrdimensionale Daten an.\n+ Links zu Video und Folien"
- },
- {
- "id": 96,
- "name": "Quick-Sort Beispiel",
- "description": "In diesem Beispiel wird die Funktionsweise von Quick-Sort, sowie die Laufzeit betrachtet."
- },
- {
- "id": 97,
- "name": "Mediane Beispiel",
- "description": "In diesem Teil der Übung schauen wir uns noch einmal genauer an, was Mediane sind, wie man sie algorithmisch bestimmen kann und in welcher Laufzeit das möglich ist."
- },
- {
- "id": 98,
- "name": "kd-Bäume (Exkurs)",
- "description": "kd-Bäume sind Bäume mit einer höheren Dimension. Mithilfe der Idee den Baum abwechselnd nach x- und y-Koordinate zu durchsuchen und so zu konstruieren entsteht ein Algorithmus mit dem man mehrdimensionale Suchbäume erstellen kann. Auch schauen wir uns an, wie man in einem solchen Baum sucht."
- },
- {
- "id": 99,
- "name": "(parallelisierte) Sortierverfahren",
- "description": "In dieser Vorlesung beenden wir das Kapitel zum Thema Sortieralgorithmen und werfen abschließend einen Blick auf parallelisierte Sortierverfahren.\n+ Links zu Video und Folien/Notizen"
- },
- {
- "id": 100,
- "name": "Bubble-Sort Beispiel",
- "description": "Einige Beispiele, wie Bubble-Sort funktioniert, inklusive einiger verschiedener Darstellungen/Animationen und dem Vergleich mit Quick-Sort."
- },
- {
- "id": 101,
- "name": "paralleles Bubble-Sort",
- "description": "Mithilfe von Parallelisierung lässt sich Bubble-Sort auch in linearer Zeit umsetzen. Die Idee dafür wird hier einmal erläutert."
- },
- {
- "id": 102,
- "name": "Bogo-Sort",
- "description": "Bogo-Sort ist ein eher als Scherz gemeinter Sortieralgorithmus. Dabei wird die gegebene Menge solange zufällig durchpermutiert und überprüft bis die korrekte Lösung erreicht ist."
- },
- {
- "id": 103,
- "name": "Zusammenfassung",
- "description": "Diese Vorlesung markiert das Ende der Vorlesungszeit. Wir gehen deshalb noch einmal Rückblickend über die verschiedenen Themen die in den vergangenen Monaten behandelt wurden und geben die Möglichkeit Fragen zu stellen.\n+ Links zu Video und Folien"
- },
- {
- "id": 104,
- "name": "Klausurvorbereitung",
- "description": "Die letzte große Übung von AuD mit Spiel, Spaß, Spannung und vielen Fragen.\n+ Links zu Video und Folien"
- },
- {
- "id": 105,
- "name": "Einleitung",
- "description": "nan"
- },
- {
- "id": 106,
- "name": "Graphen",
- "description": "nan"
- },
- {
- "id": 107,
- "name": "Suche in Graphen",
- "description": "nan"
- },
- {
- "id": 108,
- "name": "Dynamische Datenstrukturen",
- "description": "nan"
- },
- {
- "id": 109,
- "name": "Sortieren",
- "description": "nan"
- },
- {
- "id": 0,
- "name": "AuD1",
- "description": "Algorithmen und Datenstrukturen 1"
- }
- ],
- "links": [
- {
- "source": 1,
- "target": "105",
- "type": "Vorlesung"
- },
- {
- "source": 2,
- "target": "1",
- "type": "Beispiel"
- },
- {
- "source": 3,
- "target": "1",
- "type": "Beispiel"
- },
- {
- "source": 4,
- "target": "105",
- "type": "Definition"
- },
- {
- "source": 4,
- "target": "7",
- "type": "Definition"
- },
- {
- "source": 5,
- "target": "1",
- "type": "Beispiel"
- },
- {
- "source": 6,
- "target": "1",
- "type": "Definition"
- },
- {
- "source": 7,
- "target": "105",
- "type": "Vorlesung"
- },
- {
- "source": 8,
- "target": "7",
- "type": "Definition"
- },
- {
- "source": 21,
- "target": "105",
- "type": "Ãœbung"
- },
- {
- "source": 9,
- "target": "105",
- "type": "Definition"
- },
- {
- "source": 9,
- "target": "21",
- "type": "Definition"
- },
- {
- "source": 10,
- "target": "106",
- "type": "Vorlesung"
- },
- {
- "source": 11,
- "target": "14",
- "type": "Beispiel"
- },
- {
- "source": 12,
- "target": "106",
- "type": "Definition"
- },
- {
- "source": 12,
- "target": "15",
- "type": "Definition"
- },
- {
- "source": 12,
- "target": "17",
- "type": "Definition"
- },
- {
- "source": 12,
- "target": "19",
- "type": "Definition"
- },
- {
- "source": 12,
- "target": "20",
- "type": "Definition"
- },
- {
- "source": 13,
- "target": "14",
- "type": "Vorlesung"
- },
- {
- "source": 13,
- "target": "15",
- "type": "Vorlesung"
- },
- {
- "source": 14,
- "target": "106",
- "type": "Definition"
- },
- {
- "source": 15,
- "target": "106",
- "type": "Definition"
- },
- {
- "source": 16,
- "target": "106",
- "type": "Ãœbung"
- },
- {
- "source": 17,
- "target": "18",
- "type": "Vorlesung"
- },
- {
- "source": 18,
- "target": "106",
- "type": "Algorithmus"
- },
- {
- "source": 19,
- "target": "18",
- "type": "Algorithmus"
- },
- {
- "source": 20,
- "target": "18",
- "type": "Algorithmus"
- },
- {
- "source": 22,
- "target": "107",
- "type": "Vorlesung"
- },
- {
- "source": 23,
- "target": "107",
- "type": "Ãœbung"
- },
- {
- "source": 23,
- "target": "16",
- "type": "Ãœbung"
- },
- {
- "source": 24,
- "target": "25",
- "type": "Vorlesung"
- },
- {
- "source": 25,
- "target": "107",
- "type": "Algorithmus"
- },
- {
- "source": 26,
- "target": "27",
- "type": "Vorlesung"
- },
- {
- "source": 26,
- "target": "28",
- "type": "Vorlesung"
- },
- {
- "source": 26,
- "target": "29",
- "type": "Vorlesung"
- },
- {
- "source": 26,
- "target": "30",
- "type": "Vorlesung"
- },
- {
- "source": 26,
- "target": "31",
- "type": "Vorlesung"
- },
- {
- "source": 27,
- "target": "107",
- "type": "Definition"
- },
- {
- "source": 28,
- "target": "107",
- "type": "Definition"
- },
- {
- "source": 29,
- "target": "107",
- "type": "Algorithmus"
- },
- {
- "source": 29,
- "target": "25",
- "type": "Algorithmus"
- },
- {
- "source": 30,
- "target": "107",
- "type": "Algorithmus"
- },
- {
- "source": 30,
- "target": "25",
- "type": "Algorithmus"
- },
- {
- "source": 31,
- "target": "32",
- "type": "Vorlesung"
- },
- {
- "source": 31,
- "target": "33",
- "type": "Vorlesung"
- },
- {
- "source": 32,
- "target": "107",
- "type": "Definition"
- },
- {
- "source": 33,
- "target": "107",
- "type": "Definition"
- },
- {
- "source": 34,
- "target": "33",
- "type": "Vorlesung"
- },
- {
- "source": 34,
- "target": "35",
- "type": "Vorlesung"
- },
- {
- "source": 35,
- "target": "107",
- "type": "Definition"
- },
- {
- "source": 36,
- "target": "30",
- "type": "Ãœbung"
- },
- {
- "source": 36,
- "target": "29",
- "type": "Ãœbung"
- },
- {
- "source": 36,
- "target": "24",
- "type": "Ãœbung"
- },
- {
- "source": 37,
- "target": "35",
- "type": "Ãœbung"
- },
- {
- "source": 38,
- "target": "107",
- "type": "Vorlesung"
- },
- {
- "source": 39,
- "target": "35",
- "type": "Vorlesung"
- },
- {
- "source": 39,
- "target": "29",
- "type": "Vorlesung"
- },
- {
- "source": 39,
- "target": "30",
- "type": "Vorlesung"
- },
- {
- "source": 40,
- "target": "23",
- "type": "Beispiel"
- },
- {
- "source": 41,
- "target": "33",
- "type": "Beispiel"
- },
- {
- "source": 42,
- "target": "25",
- "type": "Beispiel"
- },
- {
- "source": 42,
- "target": "33",
- "type": "Beispiel"
- },
- {
- "source": 43,
- "target": "26",
- "type": "Vorlesung"
- },
- {
- "source": 43,
- "target": "44",
- "type": "Vorlesung"
- },
- {
- "source": 44,
- "target": "108",
- "type": "Definition"
- },
- {
- "source": 45,
- "target": "108",
- "type": "Algorithmus"
- },
- {
- "source": 46,
- "target": "45",
- "type": "Beispiel"
- },
- {
- "source": 47,
- "target": "45",
- "type": "Beispiel"
- },
- {
- "source": 48,
- "target": "49",
- "type": "Vorlesung"
- },
- {
- "source": 48,
- "target": "50",
- "type": "Vorlesung"
- },
- {
- "source": 49,
- "target": "108",
- "type": "Definition"
- },
- {
- "source": 50,
- "target": "108",
- "type": "Algorithmus"
- },
- {
- "source": 50,
- "target": "49",
- "type": "Algorithmus"
- },
- {
- "source": 51,
- "target": "52",
- "type": "Vorlesung"
- },
- {
- "source": 52,
- "target": "49",
- "type": "Definition"
- },
- {
- "source": 52,
- "target": "108",
- "type": "Definition"
- },
- {
- "source": 53,
- "target": "52",
- "type": "Vorlesung"
- },
- {
- "source": 54,
- "target": "108",
- "type": "Algorithmus"
- },
- {
- "source": 54,
- "target": "53",
- "type": "Algorithmus"
- },
- {
- "source": 54,
- "target": "52",
- "type": "Algorithmus"
- },
- {
- "source": 55,
- "target": "108",
- "type": "Definition"
- },
- {
- "source": 56,
- "target": " 44",
- "type": "Ãœbung"
- },
- {
- "source": 56,
- "target": "45",
- "type": "Ãœbung"
- },
- {
- "source": 56,
- "target": "49",
- "type": "Ãœbung"
- },
- {
- "source": 56,
- "target": "50",
- "type": "Ãœbung"
- },
- {
- "source": 56,
- "target": "52",
- "type": "Ãœbung"
- },
- {
- "source": 56,
- "target": "54",
- "type": "Ãœbung"
- },
- {
- "source": 57,
- "target": "18",
- "type": "Beispiel"
- },
- {
- "source": 57,
- "target": "44",
- "type": "Beispiel"
- },
- {
- "source": 58,
- "target": "50",
- "type": "Beispiel"
- },
- {
- "source": 58,
- "target": "49",
- "type": "Beispiel"
- },
- {
- "source": 59,
- "target": "54",
- "type": "Beispiel"
- },
- {
- "source": 59,
- "target": "52",
- "type": "Beispiel"
- },
- {
- "source": 60,
- "target": "48",
- "type": "Vorlesung"
- },
- {
- "source": 60,
- "target": "61",
- "type": "Vorlesung"
- },
- {
- "source": 60,
- "target": "62",
- "type": "Vorlesung"
- },
- {
- "source": 60,
- "target": "63",
- "type": "Vorlesung"
- },
- {
- "source": 61,
- "target": "108",
- "type": "Definition"
- },
- {
- "source": 61,
- "target": "49",
- "type": "Definition"
- },
- {
- "source": 62,
- "target": "108",
- "type": "Definition"
- },
- {
- "source": 62,
- "target": "49",
- "type": "Definition"
- },
- {
- "source": 63,
- "target": "108",
- "type": "Definition"
- },
- {
- "source": 64,
- "target": "65",
- "type": "Vorlesung"
- },
- {
- "source": 64,
- "target": "66",
- "type": "Vorlesung"
- },
- {
- "source": 65,
- "target": "109",
- "type": "Algorithmus"
- },
- {
- "source": 66,
- "target": "67",
- "type": "Vorlesung"
- },
- {
- "source": 66,
- "target": "68",
- "type": "Vorlesung"
- },
- {
- "source": 67,
- "target": "109",
- "type": "Definition"
- },
- {
- "source": 68,
- "target": "109",
- "type": "Definition"
- },
- {
- "source": 69,
- "target": "68",
- "type": "Vorlesung"
- },
- {
- "source": 70,
- "target": "68",
- "type": "Beispiel"
- },
- {
- "source": 70,
- "target": "55",
- "type": "Beispiel"
- },
- {
- "source": 71,
- "target": "109",
- "type": "Definition"
- },
- {
- "source": 72,
- "target": "71",
- "type": "Beispiel"
- },
- {
- "source": 73,
- "target": "65",
- "type": "Ãœbung"
- },
- {
- "source": 73,
- "target": "71",
- "type": "Ãœbung"
- },
- {
- "source": 74,
- "target": "65",
- "type": "Beispiel"
- },
- {
- "source": 75,
- "target": "71",
- "type": "Beispiel"
- },
- {
- "source": 76,
- "target": "63",
- "type": "Algorithmus"
- },
- {
- "source": 76,
- "target": "77",
- "type": "Algorithmus"
- },
- {
- "source": 76,
- "target": "109",
- "type": "Algorithmus"
- },
- {
- "source": 76,
- "target": "74",
- "type": "Algorithmus"
- },
- {
- "source": 77,
- "target": "76",
- "type": "Beispiel"
- },
- {
- "source": 78,
- "target": "109",
- "type": "Algorithmus"
- },
- {
- "source": 78,
- "target": "76",
- "type": "Algorithmus"
- },
- {
- "source": 78,
- "target": "74",
- "type": "Algorithmus"
- },
- {
- "source": 79,
- "target": "80",
- "type": "Vorlesung"
- },
- {
- "source": 79,
- "target": "81",
- "type": "Vorlesung"
- },
- {
- "source": 79,
- "target": "82",
- "type": "Vorlesung"
- },
- {
- "source": 79,
- "target": "83",
- "type": "Vorlesung"
- },
- {
- "source": 80,
- "target": "109",
- "type": "Definition"
- },
- {
- "source": 81,
- "target": "109",
- "type": "Definition"
- },
- {
- "source": 82,
- "target": "109",
- "type": "Definition"
- },
- {
- "source": 82,
- "target": "81",
- "type": "Definition"
- },
- {
- "source": 83,
- "target": "109",
- "type": "Definition"
- },
- {
- "source": 84,
- "target": "83",
- "type": "Beispiel"
- },
- {
- "source": 85,
- "target": "86",
- "type": "Vorlesung"
- },
- {
- "source": 86,
- "target": "109",
- "type": "Algorithmus"
- },
- {
- "source": 87,
- "target": "86",
- "type": "Beispiel"
- },
- {
- "source": 87,
- "target": "71",
- "type": "Beispiel"
- },
- {
- "source": 88,
- "target": "90",
- "type": "Vorlesung"
- },
- {
- "source": 88,
- "target": "91",
- "type": "Vorlesung"
- },
- {
- "source": 89,
- "target": "88",
- "type": "Definition"
- },
- {
- "source": 90,
- "target": "109",
- "type": "Definition"
- },
- {
- "source": 91,
- "target": "109",
- "type": "Definition"
- },
- {
- "source": 91,
- "target": "90",
- "type": "Definition"
- },
- {
- "source": 92,
- "target": "93",
- "type": "Vorlesung"
- },
- {
- "source": 92,
- "target": "94",
- "type": "Vorlesung"
- },
- {
- "source": 93,
- "target": "109",
- "type": "Algorithmus"
- },
- {
- "source": 94,
- "target": "109",
- "type": "Algorithmus"
- },
- {
- "source": 95,
- "target": "86",
- "type": "Ãœbung"
- },
- {
- "source": 95,
- "target": "90",
- "type": "Ãœbung"
- },
- {
- "source": 95,
- "target": "91",
- "type": "Ãœbung"
- },
- {
- "source": 96,
- "target": "86",
- "type": "Beispiel"
- },
- {
- "source": 97,
- "target": "90",
- "type": "Beispiel"
- },
- {
- "source": 97,
- "target": "91",
- "type": "Beispiel"
- },
- {
- "source": 98,
- "target": "109",
- "type": "Definition"
- },
- {
- "source": 98,
- "target": "49",
- "type": "Definition"
- },
- {
- "source": 98,
- "target": "95",
- "type": "Definition"
- },
- {
- "source": 99,
- "target": "100",
- "type": "Vorlesung"
- },
- {
- "source": 99,
- "target": "101",
- "type": "Vorlesung"
- },
- {
- "source": 99,
- "target": "102",
- "type": "Vorlesung"
- },
- {
- "source": 100,
- "target": "109",
- "type": "Algorithmus"
- },
- {
- "source": 100,
- "target": "86",
- "type": "Algorithmus"
- },
- {
- "source": 101,
- "target": "100",
- "type": "Definition"
- },
- {
- "source": 102,
- "target": "109",
- "type": "Algorithmus"
- },
- {
- "source": 103,
- "target": "0",
- "type": "Vorlesung"
- },
- {
- "source": 104,
- "target": "103",
- "type": "Ãœbung"
- },
- {
- "source": 105,
- "target": "0",
- "type": "Kapitel"
- },
- {
- "source": 106,
- "target": "0",
- "type": "Kapitel"
- },
- {
- "source": 107,
- "target": "0",
- "type": "Kapitel"
- },
- {
- "source": 108,
- "target": "0",
- "type": "Kapitel"
- },
- {
- "source": 109,
- "target": "0",
- "type": "Kapitel"
- },
- {
- "source": 0,
- "target": "nan",
- "type": "Kapitel"
- }
- ]
-}
\ No newline at end of file
+ "nodes": [
+ {
+ "id": 1,
+ "name": "Einführung",
+ "description": "Eine Einführung in die Algorithmen und Datenstrukturen\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 2,
+ "name": "Rundreise Problem",
+ "description": "Gegeben: Ein Graph G = (V, E) mit Kantenlängen we, Gesucht: Eine kürzeste Rundreise, welche alle Knoten im Graphen einmal besucht und im Startknoten wieder endet."
+ },
+ {
+ "id": 3,
+ "name": "Puzzle",
+ "description": "Jeder hat schon einmal ein Puzzle gelöst, doch wie sieht das aus algorithmischer Sicht aus?"
+ },
+ {
+ "id": 4,
+ "name": "Algorithmus-Definition",
+ "description": "“Ein Algorithmus ist eine aus endlich vielen Schritten bestehende eindeutige Handlungsvorschrift zur Lösung eines Problems oder einer Klasse von Problemen.â€-Wikipedia. Dabei wird als Input eine Problembeschreibung gegeben und durch Anwendung des Algorithmus eine fertige Lösung des Problems ermittelt. Oft spielt die Laufzeit des Algorithmus eine große Rolle. Sie beschreibt, wie viele einzelne Schritte nötig sind um das Problem zu lösen, in Abhängigkeit von der Größe des Problems."
+ },
+ {
+ "id": 5,
+ "name": "Kofferpacken",
+ "description": "Kann ich alle meine Gepäckstücke auf zwei gleich große Koffer aufteilen? Gegeben: Eine Menge von n Objekten, jedes mit\\neiner Größe li; Gesamtgröße ∑ li = 2K\\nGesucht: Eine Verteilung auf zwei Koffer der Größe K"
+ },
+ {
+ "id": 6,
+ "name": "P und NP",
+ "description": "Die Klassen P und NP teilen algorithmische Probleme in zwei Kategorien auf. Die eine, bei der man mithilfe eines Algorithmus eine Lösung Pfinden kann (P) und eine zweite, bei der bisher nur das NachPrüfen einer existierenden Lösung gelingt (NP). Wenn es allerdings keine Lösung gibt, so lässt sich das bei Problemen der Klasse NP nur schlecht beweisen."
+ },
+ {
+ "id": 7,
+ "name": "Algorithmen und Datenstrukturen",
+ "description": "In dieser Vorlesung wird der Begriff 'Algorithmus' definiert und erklärt.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 8,
+ "name": "Datenstrukturen",
+ "description": "Eine Datenstruktur erlaubt es, die für eine Aufgabe notwendigen Informationen geeignet zu repräsentieren und den Zugriff und die Verwaltung während der Bearbeitung in effizienter Weise zu ermöglichen."
+ },
+ {
+ "id": 21,
+ "name": "Organisation und Pseudocode",
+ "description": "In dieser Ãœbung haben wir noch einmal organisatorische Dinge besprochen und uns mit dem Thema Pseudocode auseinandergesetzt.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 9,
+ "name": "Pseudocode",
+ "description": "Pseudocode ist eine Art Algorithmen einigermaßen einheitlich zu notieren. Dabei werden zwar Schlüsselwörter genutzt um eine gewisse Einheitlichkeit zu bieten und gleichzeitig die Logik zu beschreiben, allerdings geht es noch nicht darum einen compilierbaren Code mit korrekter Syntax zu schreiben.\\n+ Link zu Pseudocodeblatt, Übung 1"
+ },
+ {
+ "id": 10,
+ "name": "Graphen",
+ "description": "Eine Einleitung in die Welt der Graphen am wohl bekanntesten Beispiel, dem Haus des Nikolaus.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 11,
+ "name": "Haus des Nikolaus",
+ "description": "Jeder kennt das Haus vom Nikolaus, doch wie wird es gemalt? Wo setzt man den Stift an und wo wieder ab?"
+ },
+ {
+ "id": 12,
+ "name": "Eulertouren",
+ "description": "Ein Eulerweg ist ein Weg in einem Graphen, welcher alle Kanten nutzt. Eine Eulertour kehrt darüber hinaus auch zum Startknoten zurück."
+ },
+ {
+ "id": 13,
+ "name": "Graphenbegriffe",
+ "description": "Ein Graph besteht aus Knoten und Kanten das sollte inzwischen jeder wissen, doch was parallele Kanten, Schleifen, (geschlossene) Wege, Pfade, Kreise, Eulerwege/-touren, sowie Hamiltonpfade und -kreise sind wird in dieser Vorlesung noch einmal genau definiert.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 14,
+ "name": "Graph",
+ "description": "Über Graphen haben wir bereits viel gesprochen, doch was ein Graph genau ist und wie man ihn definiert erfährst du hier."
+ },
+ {
+ "id": 15,
+ "name": "Wege in Graphen",
+ "description": "Eine Kantenfolge W in einem Graphen G heißt Weg, wenn sich keine Kante darin wiederholt und geschlossener Weg (Tour), wenn man am Ende wieder am Startknoten ankommt. Wiederholt sich kein Knoten spricht man von einem Pfad. Ein Kreis ist ein geschlossener Pfad. Bei einem Eulerweg/ einer Eulertour werden alle Kanten des Graphen genutzt. Ein Hamiltonpfad/kreis nutzt hingegen alle Knoten."
+ },
+ {
+ "id": 16,
+ "name": "Beweistechniken",
+ "description": "In der Mathematik und auch in der Algorithmik spielen Beweise immer wieder eine große Rolle. Es geht darum Aussagen zu belegen, zu widerlegen oder auf bestimmte Elemente anzuwenden. Dazu gibt es verschiedene Beweistechniken, welche ihr hier finden könnt:\\n+ Link zu Beweisblatt, Übung 2"
+ },
+ {
+ "id": 17,
+ "name": "Eulertouren",
+ "description": "In dieser Vorlesung werden notwendige Bedingungen für Eulertouren erleutert. Zusätzlich wird das Kapitel 2 noch einmal zusammengefasst und es werden Algorithmen eingeführt um die uns bisher bekannten Probleme zu lösen.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 18,
+ "name": "Algorithmus Wegfindung",
+ "description": "Dieser Algorithmus (2.7) erhält als Input einen Graphen G mit höchstens zwei ungeraden Knoten und liefert als Output einen Weg in G"
+ },
+ {
+ "id": 19,
+ "name": "Algorithmus von Hierholzer",
+ "description": "Dieser Algorithmus (2.8) erhält als Input einen zusammenhängenden Graphen G mit höchstens zwei ungeraden Knoten und liefert als Output einen Eulerweg, bzw. eine Eulertour in G. Dazu wird auch Algorithmus 2.7 zum Finden von Wegen in G verwendet."
+ },
+ {
+ "id": 20,
+ "name": "Algorithmus von Fleury",
+ "description": "Dieser Algorithmus(2.13) erhält als Input einen Graphen G mit höchstens 2 ungeraden Knoten und liefert als Output einen Weg in G. Der Algorithmus hat als Grundlage Algorithmus 2.7 zum Finden von Wegen. Auch lässt sich zeigen, dass man mit diesem Algorithmus eine Eulertour/einen Eulerweg finden kann"
+ },
+ {
+ "id": 22,
+ "name": "Anwendung von Graphen",
+ "description": "In dieser Vorlesung geht es um den Einsatzzweck von Graphen und es wird am Beispiel der Erdös- und der Kevin Bacon Zahl gezeigt, welche Zusammenhänge dargestellt werden können.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 23,
+ "name": "Beweistechniken Teil 2",
+ "description": "In dieser Übung geht es um die Beweistechnik der vollständigen Induktion. Diese ist die wohl meist benutzte Beweistechnik in der Algorithmik. Auch werden Anwendungsbeispiele wie z.B. die Gauß'sche Summenformel oder der Zusammenhang in Graphen erläutert.\\n+ Links zu Video und Folien/Notizen"
+ },
+ {
+ "id": 24,
+ "name": "Graphenscan",
+ "description": "In dieser Vorlesung wird der Graphenscanalgorithmus vorgestellt um Zusammenhangskomponenten in Graphen zu finden.\\n+ Links zu Video und Folien/Notizen/Beweis"
+ },
+ {
+ "id": 25,
+ "name": "Algorithmus Graphenscan",
+ "description": "Dieser Algorithmus (3.7) erhählt als Input einen Graphen G = (V,E) und einen Knoten s darin und liefert als Output eine Knotenmenge Y aus V, die von s aus erreichbar ist, sowie eine Kantenmenge T aus E, welche die Erreichbarkeit sicherstellt"
+ },
+ {
+ "id": 26,
+ "name": "Datenstrukturen Teil 1",
+ "description": "In dieser Vorlesung werden die Datenstrukturen Warteschlange (First In - First Out) und Stapel (Last In - First Out) vorgestellt. Außerdem geht es um ihre Rolle für Algorithmen und wie man sie implementieren kann. Das ganze wird am Beispiel des Graphscan Algorithmus gezeigt und somit werden auch Breiten- und Tiefensuche eingeführt.\\n+ Links zu Video und Folien/Beispiel"
+ },
+ {
+ "id": 27,
+ "name": "Warteschlange",
+ "description": "Eine Warteschlange ist eine Datenstruktur, welche nach dem Prinzip 'First In - First Out' arbeitet. Man findet sie auch im alltäglichen Leben oft wieder, wenn man sich beispielsweise an der Kasse anstellen muss. Der Kunde der zuerst da war, wir auch zuerst bedient."
+ },
+ {
+ "id": 28,
+ "name": "Stapel",
+ "description": "Ein Stapel ist eine Datenstruktur, welche nach dem Prinzip 'Last In - First Out' arbeitet. Im alltäglichen Leben findet man diese Form der Datenstruktur beim Geschirr abwaschen, man stapelt die Teller und der Teller der zuletzt dreckig wurde wird als erstes gereinigt, da man die Teller von oben herunter nimmt."
+ },
+ {
+ "id": 29,
+ "name": "Breitensuche",
+ "description": "Die Breitensuche ist im Prinzip der Graphscan Algorithmus, ausgeführt mithilfe einer Warteschlange als Datenstruktur. Sie breitet sich aus wie eine Welle."
+ },
+ {
+ "id": 30,
+ "name": "Tiefensuche",
+ "description": "Die Breitensuche ist im Prinzip der Graphscan Algorithmus, ausgeführt mithilfe eines Stapels als Datenstruktur. Dabei werden eher einzelne Pfade gelaufen."
+ },
+ {
+ "id": 31,
+ "name": "Datenstrukturen Teil 2",
+ "description": "In dieser Vorlesung geht es einerseits um die Anwendung der Breitensuche, andererseits werden noch 2 weitere Datenstrukturen eingeführt: Die Inzidenz/-Adjazenzmatrix, sowie die Kantenliste\\n+ Links zu Video und Folien/Notizen"
+ },
+ {
+ "id": 32,
+ "name": "Inzidenz/-Adjazenzmatrix",
+ "description": "In einer Inzidenzmatrix wird mithilfe von 1en und 0en dargestellt, welche Knoten mit welchen Kanten inzident (zusammentreffend) sind. Bei einer Adjazenzmatrix wird dargestellt, welche Knoten adjazent (durch eine Kante verbunden) sind."
+ },
+ {
+ "id": 33,
+ "name": "Kanten-/Adjazenzliste",
+ "description": "Eine Kantenliste ist eine Liste bestehend aus einträgen der Form {vx, vy}, welche bedeuten, dass eine Kante zwischen vx und vy im Graphen existiert."
+ },
+ {
+ "id": 34,
+ "name": "Wachstum/O-Notation",
+ "description": "In dieser Vorlesung wird noch einmal mit den Adjazenz- und Kantenlisten abgeschlossen. Außerdem schauen wir uns einmal das Wachstum von Funktionen an und definieren und die O-Notation um damit zu arbeiten.\\n+ Links zu Video und Folien/Notizen"
+ },
+ {
+ "id": 35,
+ "name": "O-Notation",
+ "description": "Die O-Notation wird genutzt um das Wachstum von Funktionen abzuschätzen. Damit können Größenordnungen und Wachstumsverhalten beschrieben werden."
+ },
+ {
+ "id": 36,
+ "name": "Graphscan Ãœbung",
+ "description": "Simple Anwengung des Graphscan Algorithmus, einmal als Breiten- und als Tiefensuche. Wann welcher Algorithmus besser geeignet ist wird in dieser Übung erklärt."
+ },
+ {
+ "id": 37,
+ "name": "Wachstum",
+ "description": "Die O-Notation wird genutzt um das Wachstum von Funktionen abzuschätzen. In dieser Übung werden Zusammenhänge zwischen der Größe des Inputs und dem Wachstum, sowie Relationen zwischen Laufzeitklassen näher beleuchtet. Auch wird die O-Notation an verschiedenen Beispielen erklärt."
+ },
+ {
+ "id": 38,
+ "name": "Wiederholung oder\\nSuche in Graphen Zusammenfassung",
+ "description": "Noch einmal ein Rückblick auf alles, was bisher in 'Kapitel 3: Suche in Graphen' passiert ist. \\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 39,
+ "name": "Eigenschaften von DFS und BFS",
+ "description": "In dieser Vorlesung betrachten wir die Breiten- und Tiefensuche im Hinblick auf ihre Laufzeit. Dabei wird anschaulich, wie die Algorithmen arbeiten, wann man sie am besten nutzen sollte und wie man Laufzeiten beweisen kann.\\n+ Links zu Video und Folien/Notizen"
+ },
+ {
+ "id": 40,
+ "name": "Induktionsbeweise Bsp.",
+ "description": "Einige Beispiele, bei denen der Induktionsbeweis auch in der Graphentheorie zum Einsatz kommt. "
+ },
+ {
+ "id": 41,
+ "name": "Adjazenzliste",
+ "description": "Wie eine Adjazenzliste für einen Graphen erstellt werden kann wird hier einmal genauer beleuchtet."
+ },
+ {
+ "id": 42,
+ "name": "Graphscan Beispiel",
+ "description": "Hier wird der Graphscan Algorithmus einmal mithilfe einer Adjazenzliste als Datenstruktur durchgeführt."
+ },
+ {
+ "id": 43,
+ "name": "Dynamische Datenstrukturen",
+ "description": "In dieser Vorlesung beginnen wir dynamische Datenstrukturen einzuführen. Es werden Stapel, Warteschlangen und verkettete Listen vorgestellt. Außerdem beschäftigen wir uns mit binärer Suche.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 44,
+ "name": "Verkettete Liste",
+ "description": "Eine verkettete Liste ist eine dynamische Datenstruktur. Dabei werden für die einzelnen Elemente jeweils Vorgänger und Nachfolger mit gespeichert. Der Vorteil hierbei ist, dass neue Einträge überall eingefügt werden können."
+ },
+ {
+ "id": 45,
+ "name": "Binäre Suche",
+ "description": "Dieser Algorithmus (4.1) erhält als Input einen sortierten Array mit Einträgen S[I], Suchwert WERT, linke Randposition LINKS, rechte Randposition RECHTS und liefert als Output die Position von WERT zwischen Arraypositionen LINKS und RECHTS, falls existent."
+ },
+ {
+ "id": 46,
+ "name": "Binäre Suche Idee",
+ "description": "Ein einleitendes Beispiel zur Binären Suche."
+ },
+ {
+ "id": 47,
+ "name": "Binäre Suche Beispiel",
+ "description": "Der Algorithmus für die binäre Suche einmal an zwei Beispielen angewandt."
+ },
+ {
+ "id": 48,
+ "name": "Binäre Suchbäume",
+ "description": "In dieser Vorlesung beschäftigen wir uns genauer mit binären Suchbäumen und den darauf anwendbaren Operationen, wie Maximum, Minimum, einfügen und löschen von Knoten, sowie mit der binären Suche.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 49,
+ "name": "Binärer Suchbaum",
+ "description": "In dieser Definition werden die Begriffe 'gerichteter Graph/Baum', 'Höhe eines Baumes', '(voller/vollständiger) binärer Baum', 'Blatt eines Baumes', 'Teilbaum eines Knotens' und 'binärer Suchbaum' definiert und erklärt."
+ },
+ {
+ "id": 50,
+ "name": "Grundoperationen Suchbaum",
+ "description": "Minimum/Maximum finden, Suche im Baum, Nachfolger finden, Einfügen und Löschen sind die Grundoperationen, welche auf binäre Suchbäume angewendet werden können. Und hier findet ihr die Algorithmen dazu."
+ },
+ {
+ "id": 51,
+ "name": "AVL-Bäume",
+ "description": "In dieser Vorlesung beschäftigen wir uns mit speziellen binären Suchbäumen, den AVL-Bäumen und ihren Eigenschaften.\\n+ Links zu Video und Folien/Notizen"
+ },
+ {
+ "id": 52,
+ "name": "AVL-Baum",
+ "description": "Ein binärer Suchbaum ist höhenbalanciert, wenn sich für jeden Knoten v die Höhe der beiden Kinder von v um höchstens 1 unterscheidet. Ein höhenbalancierter Suchbaum heißt auch AVL-Baum."
+ },
+ {
+ "id": 53,
+ "name": "dyn. Operationen auf AVL-Bäumen",
+ "description": "In dieser Vorlesung beschäftigen wir uns mit dem Erhalt der AVL-Eigenschaft eines binären Suchbaumes bei Einfüge- und Löschoperationen. Außerdem werfen wir einen Blick auf die Fibonacci-Zahlen.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 54,
+ "name": "AVL-Rotation",
+ "description": "Dieser Algorithmus (4.9) erhält als Input einen Knoten x eines binären Suchbaumes T, Vaterknoten y, Großvaterknoten z und liefert als Output den binären Suchbaum T nach Umstrukturierung mit x, y, z."
+ },
+ {
+ "id": 55,
+ "name": "Fibonacci-Zahlen",
+ "description": "Die Fibonacci-Zahlen sind eine rekursiv definierte Zahlenfolge, bei der sich eine Zahl aus der Summe ihrer zwei Vorgänger ergibt. Dabei sind die ersten beiden Elemente gegeben als 1. Die Fibonacci-Zahlen finden sich überall in der Natur wieder und haben nicht wenig mit unserer Auffassung von Schönheit zu tun."
+ },
+ {
+ "id": 56,
+ "name": "Bäume-Übung",
+ "description": "In dieser Übung beschäftigen wir uns noch einmal genauer mit einigen Datenstrukturen wie verketteten Listen, binären Bäumen und AVL-Bäumen."
+ },
+ {
+ "id": 57,
+ "name": "Laufzeit von Algorithmus 2.7",
+ "description": "Wir betrachten einmal die Laufzeit des Hierholzer-Algorithmus (2.7) und im Zusammenhang damit auch verkettete Listen."
+ },
+ {
+ "id": 58,
+ "name": "Grundoperationen Suchbaum",
+ "description": "In diesem Teil der Übung werden einmal die Operationen Einfügen, Suchen, Vorgänger/Nachfolger finden, löschen und verschmelzen von binären Suchbäumen geübt."
+ },
+ {
+ "id": 59,
+ "name": "AVL-Baum-Operationen",
+ "description": "Wir schauen uns noch einmal genauer die AVL-Bäume an und was man damit machen kann. Insbesondere auch die Operationen Löschen und Einfügen."
+ },
+ {
+ "id": 60,
+ "name": "Dynamische Datenstrukturen 2",
+ "description": "In dieser Vorlesung schauen wir noch einmal auf das bisher in Kapitel 4 gelernte zurück. Außerdem geben wir einen Überblick über einige weitere dynamische Datenstrukturen wie Rot-Scharz-Bäumme, B-Bäume und Heaps.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 61,
+ "name": "Rot-Schwarz-Bäume",
+ "description": "Ein binärer Suchbaum heißt Rot-Schwarz-Baum, wenn er die folgenden Eigenschaften erfüllt:\\n1. Jeder Knoten ist entweder rot oder schwarz.\\n2. Die Wurzel ist schwarz.\\n3. Jedes Blatt (NIL) ist schwarz.\\n4. Wenn ein Knoten rot ist, sind seine beiden Kinder schwarz.\\n5. Für jeden Knoten enthalten alle Pfade nach unten zu einem Blatt des Teilbaumes die gleiche Anzahl schwarzer Knoten."
+ },
+ {
+ "id": 62,
+ "name": "B-Bäume",
+ "description": "B-Bäume sind binäre Suchbäume, welche für externen Speicher (HDDs) optimiert sind. Dabei wird die Höhe des Baumes minimiert und es werden den Knoten mehr Schlüssel zugewiesen."
+ },
+ {
+ "id": 63,
+ "name": "Heaps",
+ "description": "Ein gerichteter binärer Baum heißt binärer Min/Max-Heap, wenn jeder Knoten einen Schlüssel hat, alle Ebenen außer der 'letzten' genau 2 Knoten haben, auf der 'letzten' Ebene die linken n-(2^h)+1 Positionen besetzt sind und jeder Schlüssel eines Knotens höchstens/mindestens so groß ist wie die seiner Kinder."
+ },
+ {
+ "id": 64,
+ "name": "Sortieren",
+ "description": "In dieser Vorlesung geben wir eine Einführung in das Oberthema Sortieren. Wir stellen außerdem einen Sortieralgorithmus mit dem Namen Mergesort vor und stellen grundlegende Überlegungen zur Laufzeit von Sortieralgorithmen an.\\n+ Links zu Video und Folien/Notizen"
+ },
+ {
+ "id": 65,
+ "name": "Merge-Sort",
+ "description": "Dieser Algorithmus (5.1) erhält als Input ein Subarray von A=[1,...,n], der bei Index p beginnt und bei Index r endet, d.h. A[p,...,r] und liefert als Output ein sortiertes Subarray. Wichtig ist dafür auch die Subroutine (5.2), welche als Input zwei sortierte Subarrays von A=[1,...,n], d.h. A[p,...,q] und A[q+1,...,r] erhält und als Output das sortierte Subarray A[p,...,r] liefert."
+ },
+ {
+ "id": 66,
+ "name": "Sortier-Laufzeitschranken",
+ "description": "In dieser Vorlesung leiten wir konkrete Laufzeitschranken für das Problem des Sortierens einer Liste von Zahlen her. Zudem machen wir uns Gedanken über das Lösen von Rekursionsgleichungen.\\n+ Links zu Video und Folien/Notizen"
+ },
+ {
+ "id": 67,
+ "name": "Permutation",
+ "description": "Eine Permutation P ist eine Umsortierung von n Objekten."
+ },
+ {
+ "id": 68,
+ "name": "Erzeugende Funktionen",
+ "description": "Erzeugende Funktionen können genutzt werden um Rekursionen zu lösen."
+ },
+ {
+ "id": 69,
+ "name": "Erzeugende Funktionen/Mastertheorem",
+ "description": "In dieser Vorlesung besprechen wir weitere Details zu erzeugenden Funktionen und führen das Master-Theorem ein.\\n+ Links zu Video und Folien/Notizen"
+ },
+ {
+ "id": 70,
+ "name": "erzeugende Funktionen Fibonacci-Zahlen",
+ "description": "In diesem Beispiel wird einmal die erzeugende Funktion der Fibonacci-Zahlen hergeleitet."
+ },
+ {
+ "id": 71,
+ "name": "Master-Theorem",
+ "description": "Das Master-Theorem bietet eine schnelle Lösung für die Frage, in welcher Laufzeitklasse eine gegebene rekursiv definierte Funktion liegt. Dies funktioniert leider nur, solange einer der drei Fälle des Theorems auf die Funktion angewandt werden kann, ansonsten liefert das Theorem keine Aussage."
+ },
+ {
+ "id": 72,
+ "name": "Master-Theorem Beispiele",
+ "description": "Einige Beispiele, an denen das Master-Theorem und seine Funktion noch einmal verdeutlicht wird."
+ },
+ {
+ "id": 73,
+ "name": "Sortieralgorithmen und Master-Theorem",
+ "description": "Wir betrachten ein weiteres Beispiel für Mergesort und leiten erneut die Laufzeit des Sortieralgorithmus her, indem das Master-Theorem benutzt wird. Außerdem betrachten wir einen weiteren Sortieralgorithmus: Heapsort.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 74,
+ "name": "Merge-Sort Beispiel",
+ "description": "Hier wird der Merge-Sort Algorithmus einmal mit einem Beispiel komplett durchgeführt und die Laufzeit des Algorithmus betrachtet."
+ },
+ {
+ "id": 75,
+ "name": "Master-Theorem Beispiel",
+ "description": "3 weitere Beispiele, welche dabei helfen das Master-Theorem zu verstehen und anzuwenden."
+ },
+ {
+ "id": 76,
+ "name": "Max-Heaps",
+ "description": "Hier wir aufgezeigt, wie man mithilfe eines Algorithmus Max-Heaps bildet. "
+ },
+ {
+ "id": 77,
+ "name": "Max-Heaps",
+ "description": "Hier wird der Algorithmus aus der Ãœbung 6 zum Erstellen eines Max-Heaps einmal an einem Beispiel angewandt."
+ },
+ {
+ "id": 78,
+ "name": "Heapsort",
+ "description": "Heapsort ist ein Algorithmus bei dem mithilfe von Max-Heaps eine Reihe von Elementen sortiert werden kann. Der Algorithmus hat dabei eine Laufzeit von O(n log n), wie auch in Ãœbung 6 bewiesen wird."
+ },
+ {
+ "id": 79,
+ "name": "nichtlineare Rekursionen (Exkurs)",
+ "description": "In dieser Vorlesung haben wir einen Exkurs in die nichtlineare Rekursion gemacht.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 80,
+ "name": "logistische Rekursion",
+ "description": "Logistische Rekursion bezeichnet ein Wachstum proportional zu einer Größe. Dabei betrachtet man beispielsweise eine Bevölkerung, welche zwar durch Fruchtbarkeit immer weiter wächst, aber beispielsweise durch Tod auch wieder im Wachstum beschränkt wird."
+ },
+ {
+ "id": 81,
+ "name": "Mandelbrot-Menge",
+ "description": "Die\xa0Mandelbrot-Menge, benannt nach\xa0Benoît Mandelbrot, ist die\xa0Menge\xa0der\xa0komplexen Zahlen c, für welche die durch die\xa0Iteration z_0 = 0 und z_(n+1) = ((z_n)^2) +c definierte\xa0Folge\xa0(z_n) mit n aus den natürlichen Zahlen\xa0beschränkt\xa0ist. - Wikipedia"
+ },
+ {
+ "id": 82,
+ "name": "Fraktale",
+ "description": "Ein Fraktal beschreibt natürliche oder künstliche Gebilde oder geometrische Muster und ist ein von Benoît Mandelbrot geprägter Begriff. - Wikipedia"
+ },
+ {
+ "id": 83,
+ "name": "Zelluläre Automaten",
+ "description": "Zelluläre oder auch zellulare Automaten dienen der Modellierung räumlich diskreter dynamischer Systeme, wobei die Entwicklung einzelner Zellen zum Zeitpunkt t+1 primär von den Zellzuständen in einer vorgegebenen Nachbarschaft und vom eigenen Zustand zum Zeitpunkt t abhängt. - Wikipedia"
+ },
+ {
+ "id": 84,
+ "name": "Game of Life",
+ "description": "Das 'Game of Life' ist das wohl bekannteste Beispiel eines zellulären Automaten. "
+ },
+ {
+ "id": 85,
+ "name": "Quick-Sort",
+ "description": "In dieser Vorlesung kehren wir zurück zu Sortieralgorithmen und stellen den Quicksort-Algorithmus vor.\\n+ Links zu Video und Folien/Notizen"
+ },
+ {
+ "id": 86,
+ "name": "Quick-Sort",
+ "description": "Dieser Algorithmus (5.14) erhält als Input ein Subarray von A=[1,...,n], der bei Index p beginnt und bei Index r endet, d.h. A[p,...,r] und liefert als Output einen sortierten Subarray. Dabei ist auch Subroutine 5.15 wichtig, welche als Input ein Subarray von A=[1,...,n], d.h. A[p,...,r] erhält und als Output zwei Subarrays A[p,...,q-1] und A[q+1,...,r] mit A[i]≤A[q] und A[q]<A[j] für i=p,...,q-1 und j=q+1,...,r liefert."
+ },
+ {
+ "id": 87,
+ "name": "Laufzeit von Quick-Sort",
+ "description": "Die Laufzeit des Quick-Sort Algorithmus lässt sich mithilfe vom Master-Theorem ermitteln. Dazu betrachten wir die 3 Fälle best-case, average-case und worst-case für den Algorithmus."
+ },
+ {
+ "id": 88,
+ "name": "Mediane",
+ "description": "In dieser Vorlesung beschäftigen wir uns mit Medianen.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 89,
+ "name": "Standortprobleme",
+ "description": "Was ist der optimale Standort für beispielsweise ein Amazon-Lagerhaus? Idee: Die durchschnittliche Distanz zu den zu beliefernden Gebäuden minimieren. In Amerika ist dies leicht umgesetzt mit der sogenannten Manhatten-Distanz. Dieses Problem ist die Einführung in das Thema der Mediane."
+ },
+ {
+ "id": 90,
+ "name": "Median (diskret)",
+ "description": "Der Rank k eines Elements x (auch 'k-tes Element') ist definiert durch |{y ∈ X |y<=x}| = k. Also die Anzahl der Elemente, welche kleiner oder gleich x sind. Speziell heißt x Median, wenn er das [n/2]-te Element ist. [n/2] wird dabei abgerundet."
+ },
+ {
+ "id": 91,
+ "name": "Median (kontinuierlich)",
+ "description": "Der kontinuierliche Median hat als Eigenschaft, dass das sowohl Integral bis zum Median, als auch ab dem Median größer-gleich 1/2 ist."
+ },
+ {
+ "id": 92,
+ "name": "Sortieralgorithmen Sonderfälle",
+ "description": "In dieser Vorlesung beschäftigen wir uns mit Sonderfällen für Sortieralgorithmen, durch die Sortieren in linearer Zeit ermöglicht wird. Dabei werfen wir einen näheren Blick auf die Sortierverfahren Countingsort und Radixsort.\\n+ Links zu Video und Folien/Notizen"
+ },
+ {
+ "id": 93,
+ "name": "Counting-Sort",
+ "description": "Dieser Algorithmus (5.14) erhält als Input ein Array von A=[1],...,A[n] mit Schlüsselwerten aus {1,…, k} und liefert als Output eine sortierte Kopie B[1],…,B[n] von [1],...,A[n]."
+ },
+ {
+ "id": 94,
+ "name": "Radix-Sort",
+ "description": "Dieser Algorithmus (5.18) erhält als Input n Zahlen mit je d Ziffern, die k verschiedene Werte annehmen können, [1],...,A[n] und liefert als Output einen sortierten Array. Dabei geht Radix-Sort im Gegensatz zu anderen Sortieralgorithmen ziffernweise vor."
+ },
+ {
+ "id": 95,
+ "name": "Quick-Sort, Mediane, kd-Bäume",
+ "description": "In dieser Übung schauen wir uns noch einmal das Sortierverfahren Quicksort an und sprechen über die Berechnung von Medianen. Außerdem schauen wir uns mit den kd-Bäumen eine spezielle Datenstruktur für mehrdimensionale Daten an.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 96,
+ "name": "Quick-Sort Beispiel",
+ "description": "In diesem Beispiel wird die Funktionsweise von Quick-Sort, sowie die Laufzeit betrachtet."
+ },
+ {
+ "id": 97,
+ "name": "Mediane Beispiel",
+ "description": "In diesem Teil der Übung schauen wir uns noch einmal genauer an, was Mediane sind, wie man sie algorithmisch bestimmen kann und in welcher Laufzeit das möglich ist."
+ },
+ {
+ "id": 98,
+ "name": "kd-Bäume (Exkurs)",
+ "description": "kd-Bäume sind Bäume mit einer höheren Dimension. Mithilfe der Idee den Baum abwechselnd nach x- und y-Koordinate zu durchsuchen und so zu konstruieren entsteht ein Algorithmus mit dem man mehrdimensionale Suchbäume erstellen kann. Auch schauen wir uns an, wie man in einem solchen Baum sucht."
+ },
+ {
+ "id": 99,
+ "name": "(parallelisierte) Sortierverfahren",
+ "description": "In dieser Vorlesung beenden wir das Kapitel zum Thema Sortieralgorithmen und werfen abschließend einen Blick auf parallelisierte Sortierverfahren.\\n+ Links zu Video und Folien/Notizen"
+ },
+ {
+ "id": 100,
+ "name": "Bubble-Sort Beispiel",
+ "description": "Einige Beispiele, wie Bubble-Sort funktioniert, inklusive einiger verschiedener Darstellungen/Animationen und dem Vergleich mit Quick-Sort."
+ },
+ {
+ "id": 101,
+ "name": "paralleles Bubble-Sort",
+ "description": "Mithilfe von Parallelisierung lässt sich Bubble-Sort auch in linearer Zeit umsetzen. Die Idee dafür wird hier einmal erläutert."
+ },
+ {
+ "id": 102,
+ "name": "Bogo-Sort",
+ "description": "Bogo-Sort ist ein eher als Scherz gemeinter Sortieralgorithmus. Dabei wird die gegebene Menge solange zufällig durchpermutiert und überprüft bis die korrekte Lösung erreicht ist."
+ },
+ {
+ "id": 103,
+ "name": "Zusammenfassung",
+ "description": "Diese Vorlesung markiert das Ende der Vorlesungszeit. Wir gehen deshalb noch einmal Rückblickend über die verschiedenen Themen die in den vergangenen Monaten behandelt wurden und geben die Möglichkeit Fragen zu stellen.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 104,
+ "name": "Klausurvorbereitung",
+ "description": "Die letzte große Übung von AuD mit Spiel, Spaß, Spannung und vielen Fragen.\\n+ Links zu Video und Folien"
+ },
+ {
+ "id": 105,
+ "name": "Einleitung",
+ "description": "Eine Einleitung in die Welt der Algorithmen und Datenstrukturen. Was ist ein Algorithmus und wozu wird er benötigt? Und was haben Datenstrukturen damit zu tun?"
+ },
+ {
+ "id": 106,
+ "name": "Graphen",
+ "description": "Graphen sind eine wichtige Darstellungsform von Daten in der Informatik. Wie Graphen aufgebaut sind und was man alles mit ihnen machen kann wird in diesem Kapitel behandelt."
+ },
+ {
+ "id": 107,
+ "name": "Suche in Graphen",
+ "description": "Die Suche in Graphen ist ein wichtiges Werkzeug. Allerdings gibt es mehrere Wege, welche zum Ziel führen und nicht alle funktionieren gleich gut. Wie man effizient in Graphen sucht wird in diesem Kapitel behandelt."
+ },
+ {
+ "id": 108,
+ "name": "Dynamische Datenstrukturen",
+ "description": "Im Laufe der Vorlesung wurden bereits einige Datenstrukturen vorgestellt. In diesem Kapitel beschäftigen wir uns mit einer weiteren Klasse der Datenstrukturen, den dynamischen Datenstrukturen. Und damit, welche Möglichkeiten sie bieten."
+ },
+ {
+ "id": 109,
+ "name": "Sortieren",
+ "description": "Neben der Suche von Elementen spielt auch das Sortieren in der Informatik eine große Rolle. Wie man das macht wird in diesem Kapitel behandelt."
+ },
+ {
+ "id": 0,
+ "name": "AuD1",
+ "description": "Algorithmen und Datenstrukturen 1"
+ }
+ ],
+ "links": [
+ { "source": 1, "target": 105, "type": "Vorlesung" },
+ { "source": 2, "target": 1, "type": "Beispiel" },
+ { "source": 3, "target": 1, "type": "Beispiel" },
+ { "source": 4, "target": 105, "type": "Definition" },
+ { "source": 4, "target": 7, "type": "Definition" },
+ { "source": 5, "target": 1, "type": "Beispiel" },
+ { "source": 6, "target": 1, "type": "Definition" },
+ { "source": 7, "target": 105, "type": "Vorlesung" },
+ { "source": 8, "target": 7, "type": "Definition" },
+ { "source": 21, "target": 105, "type": "Ãœbung" },
+ { "source": 9, "target": 105, "type": "Definition" },
+ { "source": 9, "target": 21, "type": "Definition" },
+ { "source": 10, "target": 106, "type": "Vorlesung" },
+ { "source": 11, "target": 14, "type": "Beispiel" },
+ { "source": 12, "target": 106, "type": "Definition" },
+ { "source": 12, "target": 15, "type": "Definition" },
+ { "source": 12, "target": 17, "type": "Definition" },
+ { "source": 12, "target": 19, "type": "Definition" },
+ { "source": 12, "target": 20, "type": "Definition" },
+ { "source": 13, "target": 14, "type": "Vorlesung" },
+ { "source": 13, "target": 15, "type": "Vorlesung" },
+ { "source": 14, "target": 106, "type": "Definition" },
+ { "source": 15, "target": 106, "type": "Definition" },
+ { "source": 16, "target": 106, "type": "Ãœbung" },
+ { "source": 17, "target": 18, "type": "Vorlesung" },
+ { "source": 18, "target": 106, "type": "Algorithmus" },
+ { "source": 19, "target": 18, "type": "Algorithmus" },
+ { "source": 20, "target": 18, "type": "Algorithmus" },
+ { "source": 22, "target": 107, "type": "Vorlesung" },
+ { "source": 23, "target": 107, "type": "Ãœbung" },
+ { "source": 23, "target": 16, "type": "Ãœbung" },
+ { "source": 24, "target": 25, "type": "Vorlesung" },
+ { "source": 25, "target": 107, "type": "Algorithmus" },
+ { "source": 26, "target": 27, "type": "Vorlesung" },
+ { "source": 26, "target": 28, "type": "Vorlesung" },
+ { "source": 26, "target": 29, "type": "Vorlesung" },
+ { "source": 26, "target": 30, "type": "Vorlesung" },
+ { "source": 26, "target": 31, "type": "Vorlesung" },
+ { "source": 27, "target": 107, "type": "Definition" },
+ { "source": 28, "target": 107, "type": "Definition" },
+ { "source": 29, "target": 107, "type": "Algorithmus" },
+ { "source": 29, "target": 25, "type": "Algorithmus" },
+ { "source": 30, "target": 107, "type": "Algorithmus" },
+ { "source": 30, "target": 25, "type": "Algorithmus" },
+ { "source": 31, "target": 32, "type": "Vorlesung" },
+ { "source": 31, "target": 33, "type": "Vorlesung" },
+ { "source": 32, "target": 107, "type": "Definition" },
+ { "source": 33, "target": 107, "type": "Definition" },
+ { "source": 34, "target": 33, "type": "Vorlesung" },
+ { "source": 34, "target": 35, "type": "Vorlesung" },
+ { "source": 35, "target": 107, "type": "Definition" },
+ { "source": 36, "target": 30, "type": "Ãœbung" },
+ { "source": 36, "target": 29, "type": "Ãœbung" },
+ { "source": 36, "target": 24, "type": "Ãœbung" },
+ { "source": 37, "target": 35, "type": "Ãœbung" },
+ { "source": 38, "target": 107, "type": "Vorlesung" },
+ { "source": 39, "target": 35, "type": "Vorlesung" },
+ { "source": 39, "target": 29, "type": "Vorlesung" },
+ { "source": 39, "target": 30, "type": "Vorlesung" },
+ { "source": 40, "target": 23, "type": "Beispiel" },
+ { "source": 41, "target": 33, "type": "Beispiel" },
+ { "source": 42, "target": 25, "type": "Beispiel" },
+ { "source": 42, "target": 33, "type": "Beispiel" },
+ { "source": 43, "target": 26, "type": "Vorlesung" },
+ { "source": 43, "target": 44, "type": "Vorlesung" },
+ { "source": 44, "target": 108, "type": "Definition" },
+ { "source": 45, "target": 108, "type": "Algorithmus" },
+ { "source": 46, "target": 45, "type": "Beispiel" },
+ { "source": 47, "target": 45, "type": "Beispiel" },
+ { "source": 48, "target": 49, "type": "Vorlesung" },
+ { "source": 48, "target": 50, "type": "Vorlesung" },
+ { "source": 49, "target": 108, "type": "Definition" },
+ { "source": 50, "target": 108, "type": "Algorithmus" },
+ { "source": 50, "target": 49, "type": "Algorithmus" },
+ { "source": 51, "target": 52, "type": "Vorlesung" },
+ { "source": 52, "target": 49, "type": "Definition" },
+ { "source": 52, "target": 108, "type": "Definition" },
+ { "source": 53, "target": 52, "type": "Vorlesung" },
+ { "source": 54, "target": 108, "type": "Algorithmus" },
+ { "source": 54, "target": 53, "type": "Algorithmus" },
+ { "source": 54, "target": 52, "type": "Algorithmus" },
+ { "source": 55, "target": 108, "type": "Definition" },
+ { "source": 56, "target": 44, "type": "Ãœbung" },
+ { "source": 56, "target": 45, "type": "Ãœbung" },
+ { "source": 56, "target": 49, "type": "Ãœbung" },
+ { "source": 56, "target": 50, "type": "Ãœbung" },
+ { "source": 56, "target": 52, "type": "Ãœbung" },
+ { "source": 56, "target": 54, "type": "Ãœbung" },
+ { "source": 57, "target": 18, "type": "Beispiel" },
+ { "source": 57, "target": 44, "type": "Beispiel" },
+ { "source": 58, "target": 50, "type": "Beispiel" },
+ { "source": 58, "target": 49, "type": "Beispiel" },
+ { "source": 59, "target": 54, "type": "Beispiel" },
+ { "source": 59, "target": 52, "type": "Beispiel" },
+ { "source": 60, "target": 48, "type": "Vorlesung" },
+ { "source": 60, "target": 61, "type": "Vorlesung" },
+ { "source": 60, "target": 62, "type": "Vorlesung" },
+ { "source": 60, "target": 63, "type": "Vorlesung" },
+ { "source": 61, "target": 108, "type": "Definition" },
+ { "source": 61, "target": 49, "type": "Definition" },
+ { "source": 62, "target": 108, "type": "Definition" },
+ { "source": 62, "target": 49, "type": "Definition" },
+ { "source": 63, "target": 108, "type": "Definition" },
+ { "source": 64, "target": 65, "type": "Vorlesung" },
+ { "source": 64, "target": 66, "type": "Vorlesung" },
+ { "source": 65, "target": 109, "type": "Algorithmus" },
+ { "source": 66, "target": 67, "type": "Vorlesung" },
+ { "source": 66, "target": 68, "type": "Vorlesung" },
+ { "source": 67, "target": 109, "type": "Definition" },
+ { "source": 68, "target": 109, "type": "Definition" },
+ { "source": 69, "target": 68, "type": "Vorlesung" },
+ { "source": 70, "target": 68, "type": "Beispiel" },
+ { "source": 70, "target": 55, "type": "Beispiel" },
+ { "source": 71, "target": 109, "type": "Definition" },
+ { "source": 72, "target": 71, "type": "Beispiel" },
+ { "source": 73, "target": 65, "type": "Ãœbung" },
+ { "source": 73, "target": 71, "type": "Ãœbung" },
+ { "source": 74, "target": 65, "type": "Beispiel" },
+ { "source": 75, "target": 71, "type": "Beispiel" },
+ { "source": 76, "target": 63, "type": "Algorithmus" },
+ { "source": 76, "target": 77, "type": "Algorithmus" },
+ { "source": 76, "target": 109, "type": "Algorithmus" },
+ { "source": 76, "target": 74, "type": "Algorithmus" },
+ { "source": 77, "target": 76, "type": "Beispiel" },
+ { "source": 78, "target": 109, "type": "Algorithmus" },
+ { "source": 78, "target": 76, "type": "Algorithmus" },
+ { "source": 78, "target": 74, "type": "Algorithmus" },
+ { "source": 79, "target": 80, "type": "Vorlesung" },
+ { "source": 79, "target": 81, "type": "Vorlesung" },
+ { "source": 79, "target": 82, "type": "Vorlesung" },
+ { "source": 79, "target": 83, "type": "Vorlesung" },
+ { "source": 80, "target": 109, "type": "Definition" },
+ { "source": 81, "target": 109, "type": "Definition" },
+ { "source": 82, "target": 109, "type": "Definition" },
+ { "source": 82, "target": 81, "type": "Definition" },
+ { "source": 83, "target": 109, "type": "Definition" },
+ { "source": 84, "target": 83, "type": "Beispiel" },
+ { "source": 85, "target": 86, "type": "Vorlesung" },
+ { "source": 86, "target": 109, "type": "Algorithmus" },
+ { "source": 87, "target": 86, "type": "Beispiel" },
+ { "source": 87, "target": 71, "type": "Beispiel" },
+ { "source": 88, "target": 90, "type": "Vorlesung" },
+ { "source": 88, "target": 91, "type": "Vorlesung" },
+ { "source": 89, "target": 88, "type": "Definition" },
+ { "source": 90, "target": 109, "type": "Definition" },
+ { "source": 91, "target": 109, "type": "Definition" },
+ { "source": 91, "target": 90, "type": "Definition" },
+ { "source": 92, "target": 93, "type": "Vorlesung" },
+ { "source": 92, "target": 94, "type": "Vorlesung" },
+ { "source": 93, "target": 109, "type": "Algorithmus" },
+ { "source": 94, "target": 109, "type": "Algorithmus" },
+ { "source": 95, "target": 86, "type": "Ãœbung" },
+ { "source": 95, "target": 90, "type": "Ãœbung" },
+ { "source": 95, "target": 91, "type": "Ãœbung" },
+ { "source": 96, "target": 86, "type": "Beispiel" },
+ { "source": 97, "target": 90, "type": "Beispiel" },
+ { "source": 97, "target": 91, "type": "Beispiel" },
+ { "source": 98, "target": 109, "type": "Definition" },
+ { "source": 98, "target": 49, "type": "Definition" },
+ { "source": 98, "target": 95, "type": "Definition" },
+ { "source": 99, "target": 100, "type": "Vorlesung" },
+ { "source": 99, "target": 101, "type": "Vorlesung" },
+ { "source": 99, "target": 102, "type": "Vorlesung" },
+ { "source": 100, "target": 109, "type": "Algorithmus" },
+ { "source": 100, "target": 86, "type": "Algorithmus" },
+ { "source": 101, "target": 100, "type": "Definition" },
+ { "source": 102, "target": 109, "type": "Algorithmus" },
+ { "source": 103, "target": 0, "type": "Vorlesung" },
+ { "source": 104, "target": 103, "type": "Ãœbung" },
+ { "source": 105, "target": 0, "type": "Kapitel" },
+ { "source": 106, "target": 0, "type": "Kapitel" },
+ { "source": 107, "target": 0, "type": "Kapitel" },
+ { "source": 108, "target": 0, "type": "Kapitel" },
+ { "source": 109, "target": 0, "type": "Kapitel" }
+ ]
+}
diff --git a/display/graph.js b/display/graph.js
index 7730aea3bc160acd23464769c473c04672c1c08b..0ae8cc5c3fb13ca148f6935b4918071c9a9e424b 100644
--- a/display/graph.js
+++ b/display/graph.js
@@ -393,7 +393,15 @@ function createFullScreenButton() {
}
const dataUrl = Config.PLUGIN_PATH + "datasets/aud1.json";
-const G = new Graph(dataUrl);
-const linkoverlay = new LinkSelectionOverlay(G);
-const infooverlay = new NodeInfoOverlay(G);
-G.infooverlay = infooverlay;
+var G;
+var linkoverlay;
+var infooverlay;
+
+// Only execute, if corresponding dom is present
+if (document.getElementById("3d-graph") !== null) {
+ G = new Graph(dataUrl);
+ linkoverlay = new LinkSelectionOverlay(G);
+ infooverlay = new NodeInfoOverlay(G);
+ G.infooverlay = infooverlay;
+}
+
diff --git a/editor/editor.php b/editor/editor.php
index 79f24536eec8f6347a451231fcfd09a14f6e8789..bdf353b3776568d9d527c9e421ec0a84e60892c5 100644
--- a/editor/editor.php
+++ b/editor/editor.php
@@ -1,14 +1,10 @@
-<div id="ks-editor">
- <script src="https://unpkg.com/force-graph"></script>
- <!--<script src="../../dist/force-graph.js"></script>-->
-
+<div id="ks-editor"> <!--The id "ks-editor" indicates, that the javascript associated with this should automatically be executed-->
<h1>Interface</h1>
<div id="2d-graph"></div>
<section id="toolbar"></section>
<section>
<h3 id="selected-item">Nothing selected</h3>
<ul id="selected-params"></ul>
- <button onclick="graph.getCleanData()">Save NOT YET IMPLEMENTED</button>
<section>
<h4>Sources</h4>
<ul id="selected-sources"></ul>
@@ -21,6 +17,6 @@
<section>
<h3>Collected items</h3>
<ul id="selected-items"></ul>
- <button onclick="state.clearSelectedItems()">Clear</button>
+ <button id="clear-collection">Clear</button>
</section>
</div>
diff --git a/editor/js/display.js b/editor/js/display.js
index 5c2446ca1cd8efdb606b125d83289fdb730c354f..da979d1db8b0ddac2292946bb25f4b6c267eee8d 100644
--- a/editor/js/display.js
+++ b/editor/js/display.js
@@ -1,3 +1,8 @@
+import jQuery from "jquery";
+import { PLUGIN_PATH } from "../../config";
+import * as Graph from "./graph";
+import { graph, state } from "./editor";
+
const ID_TOOLBAR = "#toolbar";
const ID_SELECTEDITEM = "#selected-item";
const ID_SELECTED_PARAMS = "#selected-params";
@@ -11,7 +16,7 @@ const TOOL_ICON_SRC = PLUGIN_PATH + "editor/images/tools/";
const TOOL_ICON_FORMAT = ".png";
const TOOL_SELECTED_CLASS = "selected";
-class Display {
+export default class Display {
constructor(tools) {
this.tools = Object.values(tools);
this.previousTool = undefined;
@@ -20,11 +25,11 @@ class Display {
}
setSelectedTool(tool) {
- var selectedTool = jQuery(Display.getToolId(tool));
+ var selectedTool = jQuery(Display.getToolIdTag(tool));
selectedTool.addClass(TOOL_SELECTED_CLASS);
if (this.previousTool !== undefined) {
- var previousTool = jQuery(Display.getToolId(this.previousTool));
+ var previousTool = jQuery(Display.getToolIdTag(this.previousTool));
previousTool.removeClass(TOOL_SELECTED_CLASS);
}
@@ -33,19 +38,25 @@ class Display {
renderToolbar(tools) {
this.fillDomList(ID_TOOLBAR, tools, this.toolRenderer);
+
+ tools.forEach((tool) => {
+ this.toolClickEvent(tool);
+ });
}
- static getToolId(tool) {
+ static getToolIdTag(tool) {
return ID_TOOLBAR + "-" + tool.getKey();
}
+ static getToolId(tool) {
+ return Display.getToolIdTag(tool).substr(1);
+ }
+
toolRenderer(tool) {
return (
'<button id="' +
- Display.getToolId(tool).substr(1) + // Remove # from id
- '"onclick="state.setTool(TOOLS.' +
- tool.getKey() +
- ')" title="' +
+ Display.getToolId(tool) +
+ '" title="' +
tool.getName() +
'"><img src="' +
TOOL_ICON_SRC +
@@ -55,17 +66,28 @@ class Display {
);
}
+ toolClickEvent(tool) {
+ jQuery("button" + Display.getToolIdTag(tool)).on(
+ "click",
+ "",
+ tool,
+ (e) => {
+ state.setTool(e.data);
+ }
+ );
+ }
+
setSelectedItem(item) {
jQuery(ID_SELECTEDITEM).html(Display.toStr(item));
var paramsDOM = jQuery(ID_SELECTED_PARAMS);
paramsDOM.empty();
- var params = NODE_PARAMS;
+ var params = Graph.NODE_PARAMS;
if (item === undefined) {
params = [];
} else if (item.link) {
- params = LINK_PARAMS;
+ params = Graph.LINK_PARAMS;
}
params.forEach((param) => {
@@ -74,9 +96,9 @@ class Display {
DOM_LIST_ITEM +
">" +
param +
- ' <textarea>' +
+ " <textarea>" +
(item[param] === undefined ? "" : item[param]) +
- '</textarea></' +
+ "</textarea></" +
DOM_LIST_ITEM +
">"
);
@@ -86,17 +108,27 @@ class Display {
var sources = [];
var targets = [];
if (item !== undefined && item.node) {
- var nodes = graph.data[GRAPH_NODES];
+ var nodes = graph.data[Graph.GRAPH_NODES];
for (var i = 0; i < nodes.length; i++) {
- if (graph.existsLink(nodes[i][NODE_ID], item[NODE_ID])) {
+ if (
+ graph.existsLink(
+ nodes[i][Graph.NODE_ID],
+ item[Graph.NODE_ID]
+ )
+ ) {
sources.push(nodes[i]);
- } else if (graph.existsLink(item[NODE_ID], nodes[i][NODE_ID])) {
+ } else if (
+ graph.existsLink(
+ item[Graph.NODE_ID],
+ nodes[i][Graph.NODE_ID]
+ )
+ ) {
targets.push(nodes[i]);
}
}
} else if (item !== undefined && item.link) {
- sources.push(item[LINK_SOURCE]);
- targets.push(item[LINK_TARGET]);
+ sources.push(item[Graph.LINK_SOURCE]);
+ targets.push(item[Graph.LINK_TARGET]);
}
this.fillDomList(ID_SELECTED_SOURCES, sources, this.graphItemRenderer);
@@ -132,12 +164,12 @@ class Display {
}
if (item.node) {
- return item[NODE_LABEL] + " [" + item[NODE_ID] + "]";
+ return item[Graph.NODE_LABEL] + " [" + item[Graph.NODE_ID] + "]";
} else if (item.link) {
return (
- Display.toStr(item[LINK_SOURCE]) +
+ Display.toStr(item[Graph.LINK_SOURCE]) +
" <-> " +
- Display.toStr(item[LINK_TARGET])
+ Display.toStr(item[Graph.LINK_TARGET])
);
} else {
return "UNDEFINED";
diff --git a/editor/js/editor.js b/editor/js/editor.js
index cc24322161303aded4172cccdaf0f864da3928b7..5419fcfcab39c4ab0e424e041233578c5388d1a0 100644
--- a/editor/js/editor.js
+++ b/editor/js/editor.js
@@ -1,37 +1,41 @@
-var state;
-var graph;
+import { State } from "./state";
+import * as Graph from "./graph";
+import ForceGraph from "force-graph";
+import * as Interactions from "./interactions";
+
+
+export var state;
+export var graph;
var graphObj;
window.onload = function () {
- fetch(JSON_CONFIG)
+ // Only execute, if corresponding dom is present
+ if (document.getElementById("ks-editor") === null) {
+ return;
+ }
+
+ document.onkeydown = (e) => state.onKeyDown(e);
+ document.onkeyup = (e) => state.onKeyUp(e);
+
+ Interactions.initInteractions();
+
+ fetch(Graph.JSON_CONFIG)
.then((r) => {
return r.json();
})
.then((graphConfig) => {
state = new State();
- graph = new Graph(graphConfig);
+ graph = new Graph.Graph(graphConfig);
load();
// Deactivate physics after a short delay
setTimeout(() => {
graph.stopPhysics();
graph.storeCurrentData("Physics stopped");
- }, STOP_PHYSICS_DELAY);
+ }, Graph.STOP_PHYSICS_DELAY);
});
};
-document.onkeydown = (e) => state.onKeyDown(e);
-document.onkeyup = (e) => state.onKeyUp(e);
-
-function downloadJson() {
- // TODO: Clean up
- // source: https://stackoverflow.com/a/42883108/7376120
- var jsonBlob = new Blob([JSON.stringify(getOnlygraph.data())], {
- type: "application/json;charset=utf-8",
- });
- var link = window.URL.createObjectURL(jsonBlob);
- window.location = link;
-}
function extractPositions(event) {
return {
@@ -48,8 +52,9 @@ function load() {
.height(600)
.width(width)
.graphData(graph.data)
- .nodeLabel(NODE_LABEL)
- .nodeAutoColorBy(NODE_GROUP)
+ .nodeLabel(Graph.NODE_LABEL)
+ .linkColor((link) => state.linkColor(link))
+ .nodeColor((node) => state.nodeColor(node))
.onNodeClick((node) => state.onNodeClick(node))
.autoPauseRedraw(false) // keep redrawing after engine has stopped
.linkWidth((link) => state.linkWidth(link))
@@ -61,7 +66,7 @@ function load() {
state.onBackgroundClick(event, extractPositions(event))
)
.nodeCanvasObjectMode((node) => state.nodeCanvasObjectMode(node))
- .nodeCanvasObject((node, ctx) => state.nodeCanvasObject(node, ctx))
+ .nodeCanvasObject((node, ctx, globalScale) => state.nodeCanvasObject(node, ctx, globalScale))
.onLinkClick((link) => state.onLinkClick(link));
graph.onChangeCallbacks.push((data) => {
diff --git a/editor/js/graph.js b/editor/js/graph.js
index cefc9a4b0b6c956a97ce3bdd7ffb90ec14408c66..86184ddc0ab0a2c5618586ebcbb18d57a9ac9d3d 100644
--- a/editor/js/graph.js
+++ b/editor/js/graph.js
@@ -1,33 +1,37 @@
-const NODE_LABEL = "name";
-const NODE_ID = "id";
-const NODE_GROUP = "group";
-const NODE_DESCRIPTION = "description";
-const NODE_IMAGE = "image";
+import ManagedData from "./manageddata";
+import { PLUGIN_PATH, COLOR_PALETTE } from "../../config";
-const LINK_SOURCE = "source";
-const LINK_TARGET = "target";
-const LINK_TYPE = "type";
-const LINK_PARTICLE_COUNT = 4;
+export const NODE_LABEL = "name";
+export const NODE_ID = "id";
+export const NODE_GROUP = "group";
+export const NODE_DESCRIPTION = "description";
+export const NODE_IMAGE = "image";
-const GRAPH_NODES = "nodes";
-const GRAPH_LINKS = "links";
+export const LINK_SOURCE = "source";
+export const LINK_TARGET = "target";
+export const LINK_TYPE = "type";
+export const LINK_PARTICLE_COUNT = 4;
-const IMAGE_SIZE = 12;
-const IMAGE_SRC = PLUGIN_PATH + "datasets/images/";
+export const GRAPH_NODES = "nodes";
+export const GRAPH_LINKS = "links";
-const LINK_PARAMS = [LINK_TYPE];
-const NODE_PARAMS = [NODE_ID, NODE_LABEL, NODE_IMAGE, NODE_DESCRIPTION];
-const LINK_SIM_PARAMS = ["index"];
-const NODE_SIM_PARAMS = ["index", "x", "y", "vx", "vy", "fx", "fy"]; // Based on https://github.com/d3/d3-force#simulation_nodes
+export const IMAGE_SIZE = 12;
+export const IMAGE_SRC = PLUGIN_PATH + "datasets/images/";
-const JSON_CONFIG = PLUGIN_PATH + "datasets/aud1.json";
+export const LINK_PARAMS = [LINK_TYPE];
+export const NODE_PARAMS = [NODE_ID, NODE_LABEL, NODE_IMAGE, NODE_DESCRIPTION];
+export const LINK_SIM_PARAMS = ["index"];
+export const NODE_SIM_PARAMS = ["index", "x", "y", "vx", "vy", "fx", "fy"]; // Based on https://github.com/d3/d3-force#simulation_nodes
-const STOP_PHYSICS_DELAY = 5000; // ms
+export const JSON_CONFIG = PLUGIN_PATH + "datasets/aud1v2.json";
-class Graph extends ManagedData {
+export const STOP_PHYSICS_DELAY = 5000; // ms
+
+export class Graph extends ManagedData {
constructor(data) {
super(Graph.addIdentifiers(data));
+ this.calculateLinkTypes();
this.onChangeCallbacks = [];
}
@@ -47,6 +51,29 @@ class Graph extends ManagedData {
return this.getCleanData(data, true);
}
+ /**
+ * Based on the function from the 3d-graph code from @JoschaRode
+ */
+ calculateLinkTypes() {
+ const linkClasses = [];
+
+ this.data[GRAPH_LINKS].forEach((link) =>
+ linkClasses.push(link[LINK_TYPE])
+ );
+
+ this.linkTypes = [...new Set(linkClasses)];
+ }
+
+ getLinkColor(link) {
+ return this.getLinkTypeColor(link[LINK_TYPE])
+ }
+
+ getLinkTypeColor(linkClass) {
+ var classIndex = this.linkTypes.indexOf(linkClass);
+
+ return COLOR_PALETTE[classIndex % COLOR_PALETTE.length];
+ }
+
deleteNode(nodeId) {
// Delete node from nodes
this.data[GRAPH_NODES] = this.data[GRAPH_NODES].filter(
@@ -163,11 +190,15 @@ class Graph extends ManagedData {
cleanData[GRAPH_NODES] = [];
data[GRAPH_LINKS].forEach((link) =>
- cleanData[GRAPH_LINKS].push(this.getCleanLink(link, simulationParameters))
+ cleanData[GRAPH_LINKS].push(
+ this.getCleanLink(link, simulationParameters)
+ )
);
data[GRAPH_NODES].forEach((node) =>
- cleanData[GRAPH_NODES].push(this.getCleanNode(node, simulationParameters))
+ cleanData[GRAPH_NODES].push(
+ this.getCleanNode(node, simulationParameters)
+ )
);
return cleanData;
diff --git a/editor/js/interactions.js b/editor/js/interactions.js
new file mode 100644
index 0000000000000000000000000000000000000000..c2957e377a384c6c211056d87599c82910ba0d1f
--- /dev/null
+++ b/editor/js/interactions.js
@@ -0,0 +1,11 @@
+import jQuery from "jquery";
+import { state } from "./editor";
+
+/**
+ * Initiates all the handlers for button presses and input changes.
+ */
+export function initInteractions() {
+ jQuery("button#clear-collection").on("click", () => {
+ state.clearSelectedItems();
+ });
+}
diff --git a/editor/js/manageddata.js b/editor/js/manageddata.js
index d97d0d23889104c49ea805ff2997fcf0524be40f..05e18692786ef02ebe31cbb1e987f47c322e6312 100644
--- a/editor/js/manageddata.js
+++ b/editor/js/manageddata.js
@@ -1,7 +1,7 @@
-class ManagedData {
+export default class ManagedData {
constructor(data) {
this.data = data;
- this.history = [];
+ this.history = []; // Newest state is always at 0
this.historyPosition = 0;
this.storeCurrentData("Initial state");
@@ -11,27 +11,32 @@ class ManagedData {
onRedo() {}
undo() {
- if (this.historyPosition + 1 >= this.history.length) {
+ if (this.step(1)) {
+ this.onUndo();
+ return true;
+ } else {
return false;
}
-
- this.historyPosition += 1;
- this.data = JSON.parse(this.history[this.historyPosition].data);
-
- this.onUndo();
-
- return true;
}
redo() {
- if (this.historyPosition <= 0) {
+ if (this.step(-1)) {
+ this.onRedo();
+ return true;
+ } else {
return false;
}
+ }
- this.historyPosition -= 1;
- this.data = JSON.parse(this.history[this.historyPosition].data);
+ step(direction = 1) {
+ var newHistoryPosition = this.historyPosition + Math.sign(direction);
- this.onRedo();
+ if (newHistoryPosition >= this.history.length || newHistoryPosition < 0) {
+ return false;
+ }
+
+ this.historyPosition = newHistoryPosition;
+ this.data = JSON.parse(this.history[this.historyPosition].data);
return true;
}
diff --git a/editor/js/state.js b/editor/js/state.js
index 5f6cdfa386b265abf518ccba0b2f566cf2669bf8..d779f3dd07b89a439c9c0289176fc3990b5d19e5 100644
--- a/editor/js/state.js
+++ b/editor/js/state.js
@@ -1,4 +1,16 @@
-const TOOLS = {
+import Tool from "./tools/tool";
+import UndoTool from "./tools/undotool";
+import RedoTool from "./tools/redotool";
+import SelectTool from "./tools/selecttool";
+import CollectTool from "./tools/collecttool";
+import DeleteTool from "./tools/deletetool";
+import AddNodeTool from "./tools/addnodetool";
+import ConnectTool from "./tools/connecttool";
+import { graph } from "./editor";
+import Display from "./display";
+import * as Graph from "./graph";
+
+export const TOOLS = {
undo: new UndoTool("undo"),
redo: new RedoTool("redo"),
select: new SelectTool("select"),
@@ -8,13 +20,13 @@ const TOOLS = {
connect: new ConnectTool("connect"),
};
-const CONTEXT = {
+export const CONTEXT = {
node: "node",
link: "link",
mixed: "mixed",
};
-class State extends Tool {
+export class State extends Tool {
constructor() {
super("State");
@@ -78,6 +90,14 @@ class State extends Tool {
this.tool.onLinkClick(link);
}
+ linkColor(link) {
+ return graph.getLinkColor(link);
+ }
+
+ nodeColor(node) {
+ return 'lightblue';
+ }
+
onKeyDown(key) {
var id = this.getKeyId(key);
var previous = this.keyStates[id];
@@ -104,7 +124,7 @@ class State extends Tool {
return key.keyCode;
}
- nodeCanvasObject(node, ctx) {
+ nodeCanvasObject(node, ctx, globalScale) {
var toolValue = this.tool.nodeCanvasObject(node, ctx);
if (toolValue !== undefined) {
@@ -122,20 +142,36 @@ class State extends Tool {
}
// Draw image
- if (node[NODE_IMAGE] !== undefined) {
- var path = IMAGE_SRC + node[NODE_IMAGE];
+ if (node[Graph.NODE_IMAGE] !== undefined) {
+ var path = Graph.IMAGE_SRC + node[Graph.NODE_IMAGE];
var img = new Image();
img.src = path;
ctx.drawImage(
img,
- node.x - IMAGE_SIZE / 2,
- node.y - IMAGE_SIZE / 2,
- IMAGE_SIZE,
- IMAGE_SIZE
+ node.x - Graph.IMAGE_SIZE / 2,
+ node.y - Graph.IMAGE_SIZE / 2,
+ Graph.IMAGE_SIZE,
+ Graph.IMAGE_SIZE
);
}
+ // Draw label
+ const label = node[Graph.NODE_LABEL];
+ const fontSize = 11/globalScale;
+ ctx.font = `${fontSize}px Sans-Serif`;
+ const textWidth = ctx.measureText(label).width;
+ const bckgDimensions = [textWidth, fontSize].map(n => n + fontSize * 0.2); // some padding
+
+ const nodeHeightOffset = Graph.IMAGE_SIZE / 3 + bckgDimensions[1];
+ ctx.fillStyle = 'rgba(0, 0, 0, 0.5)';
+ ctx.fillRect(node.x - bckgDimensions[0] / 2, node.y - bckgDimensions[1] / 2 + nodeHeightOffset, ...bckgDimensions);
+
+ ctx.textAlign = 'center';
+ ctx.textBaseline = 'middle';
+ ctx.fillStyle = 'white';
+ ctx.fillText(label, node.x, node.y + nodeHeightOffset);
+
// TODO: Render label as always visible
}
@@ -148,10 +184,10 @@ class State extends Tool {
ctx.fillStyle = color;
ctx.fillRect(
- node.x - IMAGE_SIZE / 2,
- node.y - IMAGE_SIZE / 2,
- IMAGE_SIZE,
- IMAGE_SIZE
+ node.x - Graph.IMAGE_SIZE / 2,
+ node.y - Graph.IMAGE_SIZE / 2,
+ Graph.IMAGE_SIZE,
+ Graph.IMAGE_SIZE
); // draw square as pointer trap
}
@@ -192,7 +228,7 @@ class State extends Tool {
return toolValue;
}
- return this.isLinkHighlighted(link) ? LINK_PARTICLE_COUNT : 0;
+ return this.isLinkHighlighted(link) ? Graph.LINK_PARTICLE_COUNT : 0;
}
onBackgroundClick(event, positions) {
@@ -208,7 +244,7 @@ class State extends Tool {
isLinkHighlighted(link) {
return (
this.selectedItem === link ||
- graph.isLinkOnNode(link, state.selectedItem)
+ graph.isLinkOnNode(link, this.selectedItem)
);
}
}
diff --git a/editor/js/tools/addnodetool.js b/editor/js/tools/addnodetool.js
index c72c189d8ac795d2ab22be6553476e07dc359a76..52a74c9d73fd52084b543e8ef5c9fcf6fddceba7 100644
--- a/editor/js/tools/addnodetool.js
+++ b/editor/js/tools/addnodetool.js
@@ -1,4 +1,7 @@
-class AddNodeTool extends Tool {
+import Tool from "./tool";
+import { graph, state } from "../editor";
+
+export default class AddNodeTool extends Tool {
constructor(key) {
super("Add node", "addnode", key);
}
@@ -10,7 +13,7 @@ class AddNodeTool extends Tool {
node.fx = positions.graph.x;
node.fy = positions.graph.y;
- var node = graph.addNode(node);
+ node = graph.addNode(node);
if (node === undefined) {
console.error("Couldn't add new node");
diff --git a/editor/js/tools/collecttool.js b/editor/js/tools/collecttool.js
index fa2ab96c0371bcccf9f1202d30920c93820832d7..472163a61dafbdb1ba6f34ab6aeddde8bdb6dd5a 100644
--- a/editor/js/tools/collecttool.js
+++ b/editor/js/tools/collecttool.js
@@ -1,4 +1,8 @@
-class CollectTool extends Tool {
+import Tool from "./tool";
+import { state } from "../editor";
+import { CONTEXT } from "../state";
+
+export default class CollectTool extends Tool {
constructor(key) {
super("Collect", "collect", key);
}
@@ -34,4 +38,4 @@ class CollectTool extends Tool {
state.setTool(state.previousTool);
}
}
-}
\ No newline at end of file
+}
diff --git a/editor/js/tools/connecttool.js b/editor/js/tools/connecttool.js
index cd47b504f0ed047920382266d6deb7d6c15d769a..5fb9de144545ec2e6d2940a7833e832ad2884243 100644
--- a/editor/js/tools/connecttool.js
+++ b/editor/js/tools/connecttool.js
@@ -1,6 +1,10 @@
+import Tool from "./tool";
+import { graph, state } from "../editor";
+import * as Graph from "../graph";
+
const KEEP_SOURCE_KEY_ID = 17;
-class ConnectTool extends Tool {
+export default class ConnectTool extends Tool {
constructor(key) {
super("Connect two nodes", "connect", key);
this.keepSource = false;
@@ -8,13 +12,19 @@ class ConnectTool extends Tool {
onNodeClick(node) {
// Is a first node selected?
- if (state.selectedItem === undefined || state.selectedItem.node === false) {
+ if (
+ state.selectedItem === undefined ||
+ state.selectedItem.node === false
+ ) {
state.setSelectedItem(node);
return;
}
// Add new link
- var link = graph.addLink(state.selectedItem[NODE_ID], node[NODE_ID]);
+ var link = graph.addLink(
+ state.selectedItem[Graph.NODE_ID],
+ node[Graph.NODE_ID]
+ );
if (link === undefined) {
console.error("Could not create new link");
@@ -43,4 +53,4 @@ class ConnectTool extends Tool {
this.keepSource = false;
}
}
-}
\ No newline at end of file
+}
diff --git a/editor/js/tools/deletetool.js b/editor/js/tools/deletetool.js
index 35110df55b173e77ffa172fd710974f81388f3b4..64a3cf41bacc02492bfd5246ee44a639ee5420e0 100644
--- a/editor/js/tools/deletetool.js
+++ b/editor/js/tools/deletetool.js
@@ -1,13 +1,20 @@
-class DeleteTool extends Tool {
+import Tool from "./tool";
+import { graph } from "../editor";
+import * as Graph from "../graph";
+
+export default class DeleteTool extends Tool {
constructor(key) {
super("Delete", "delete", key);
}
onNodeClick(node) {
- graph.deleteNode(node[NODE_ID]);
+ graph.deleteNode(node[Graph.NODE_ID]);
}
onLinkClick(link) {
- graph.deleteLink(link[LINK_SOURCE][NODE_ID], link[LINK_TARGET][NODE_ID]);
+ graph.deleteLink(
+ link[Graph.LINK_SOURCE][Graph.NODE_ID],
+ link[Graph.LINK_TARGET][Graph.NODE_ID]
+ );
}
-}
\ No newline at end of file
+}
diff --git a/editor/js/tools/redotool.js b/editor/js/tools/redotool.js
index 2cbe00db033248a0496bf370e3b9879fc0661a8a..1334b04ee37fc6aa6705ad76a0cb7dcd776a7d6b 100644
--- a/editor/js/tools/redotool.js
+++ b/editor/js/tools/redotool.js
@@ -1,4 +1,7 @@
-class RedoTool extends Tool {
+import Tool from "./tool";
+import { graph, state } from "../editor";
+
+export default class RedoTool extends Tool {
constructor(key) {
super("Redo", "redo", key);
}
diff --git a/editor/js/tools/selecttool.js b/editor/js/tools/selecttool.js
index 24b518f1c77515666039d381ecab15d3fe06c731..921263e667f5530c35c5501645a0fe6345de31bf 100644
--- a/editor/js/tools/selecttool.js
+++ b/editor/js/tools/selecttool.js
@@ -1,4 +1,8 @@
-class SelectTool extends Tool {
+import Tool from "./tool";
+import { state } from "../editor";
+import { TOOLS } from "../state";
+
+export default class SelectTool extends Tool {
constructor(key) {
super("Select", "select", key);
}
@@ -20,4 +24,4 @@ class SelectTool extends Tool {
state.setTool(TOOLS.collect);
}
}
-}
\ No newline at end of file
+}
diff --git a/editor/js/tools/tool.js b/editor/js/tools/tool.js
index 76b9ea6bc427a080e76f0425b7fb4294170185fd..e3fade0276387f02f241a2fa77797eef2f48392e 100644
--- a/editor/js/tools/tool.js
+++ b/editor/js/tools/tool.js
@@ -1,4 +1,4 @@
-class Tool {
+export default class Tool {
constructor(name, icon, key) {
this.name = name;
this.icon = icon;
@@ -54,7 +54,7 @@ class Tool {
}
}
- nodeCanvasObject(node, ctx) {
+ nodeCanvasObject(node, ctx, globalScale) {
if (this.warnings) {
console.warn('Method "nodeCanvasObject" not implemented.');
}
@@ -92,11 +92,25 @@ class Tool {
}
}
- onBackgroundClick(event, positions) {
+ linkColor(link) {
+ if (this.warnings) {
+ console.warn(
+ 'Method "linkColor" not implemented.'
+ );
+ }
+ }
+
+ nodeColor(node) {
if (this.warnings) {
console.warn(
- 'Method "onBackgroundClick" not implemented.'
+ 'Method "nodeColor" not implemented.'
);
}
}
+
+ onBackgroundClick(event, positions) {
+ if (this.warnings) {
+ console.warn('Method "onBackgroundClick" not implemented.');
+ }
+ }
}
diff --git a/editor/js/tools/undotool.js b/editor/js/tools/undotool.js
index 98af6eb1042da701f02a8f6b14559a87ec2ecb0c..f1a48dfc3de8b902127e523a47c5112e41695dd0 100644
--- a/editor/js/tools/undotool.js
+++ b/editor/js/tools/undotool.js
@@ -1,10 +1,13 @@
-class UndoTool extends Tool {
+import Tool from "./tool";
+import { graph, state } from "../editor";
+
+export default class UndoTool extends Tool {
constructor(key) {
super("Undo", "undo", key);
}
-
+
onToolActivate() {
graph.undo();
- state.setTool(state.previousTool)
+ state.setTool(state.previousTool);
}
-}
\ No newline at end of file
+}
diff --git a/index.js b/index.js
index b9e98c56c957c974ebd8daa1b3d843db081de6cc..14f550c7c68c603cefd631fc7c5524de100d3544 100644
--- a/index.js
+++ b/index.js
@@ -1,3 +1,4 @@
import "./kg-style.css";
import "./display/graph";
+import "./editor/js/editor";
diff --git a/knowledge-space.php b/knowledge-space.php
index a7299cf60d5d75c863c248ce54d332476a88ba90..fd3d3351a848143874fdf97f3d23919fcc240353 100644
--- a/knowledge-space.php
+++ b/knowledge-space.php
@@ -11,86 +11,47 @@ $GLOBALS['build'] = 'debug';
function ks_add_graph(): string
{
- $div = '<div id="3d-graph"></div>';
+ $div = '<div id="3d-graph"></div>'; // The id "3d-graph" indicates, that the javascript associated with this should automatically be executed
$plugin_dir = plugin_dir_url(__FILE__);
//$dataset = $plugin_dir.'datasets/miserables.json';
$variables = "<script>
var plugin_path = '$plugin_dir';
</script>";
- $script_path = $plugin_dir.'build'.DIRECTORY_SEPARATOR.$GLOBALS['build'].DIRECTORY_SEPARATOR.'graph.js';
+ $script_path = $plugin_dir . 'build' . DIRECTORY_SEPARATOR . $GLOBALS['build'] . DIRECTORY_SEPARATOR . 'graph.js';
$script = "<script src='$script_path'></script>";
//wp_enqueue_script('kg-script', $script_path);
- return $div . $variables. $script;
+ return $div . $variables . $script;
}
function ks_add_editor()
{
ks_add_editor_dependencies();
- require_once(__DIR__.'/editor/editor.php');
-}
-
-function ks_add_editor_dependencies()
-{
- wp_enqueue_script('jquery'); // Should be wp_enqueue_script('jquery'), but doesn't work
-
- ks_enqueue_script('dataset.js');
- ks_enqueue_script('editor/js/manageddata.js');
- ks_enqueue_script('editor/js/graph.js', ["manageddata"]);
- ks_enqueue_script('editor/js/tools/tool.js');
- ks_enqueue_script('editor/js/tools/undotool.js', ["tool"]);
- ks_enqueue_script('editor/js/tools/redotool.js', ["tool"]);
- ks_enqueue_script('editor/js/tools/selecttool.js', ["tool"]);
- ks_enqueue_script('editor/js/tools/collecttool.js', ["tool"]);
- ks_enqueue_script('editor/js/tools/deletetool.js', ["tool"]);
- ks_enqueue_script('editor/js/tools/addnodetool.js', ["tool"]);
- ks_enqueue_script('editor/js/tools/connecttool.js', ["tool"]);
- ks_enqueue_script('editor/js/display.js', []);
- ks_enqueue_script('editor/js/state.js', ["tool", "display"]);
- ks_enqueue_script('editor/js/editor.js', ["state", "graph", "dataset"]);
-
- ks_enqueue_style('editor/css/editor.css');
-}
-function ks_enqueue_script($relative_path, $dependencies = array())
-{
- $prefix = "ks";
- $type = "script";
- $script_name = end(explode("/", $relative_path));
- $script_name = explode(".", $script_name)[0];
-
- for ($i = 0; $i < sizeof($dependencies); $i++) {
- $dependencies[$i] = $prefix . "-" . $dependencies[$i] . "-" . $type;
- }
-
- // Source: https://developer.wordpress.org/reference/functions/wp_enqueue_script/ a comment from Andrija Naglic
- // $file_version = date("ymd-Gis", filemtime(plugin_dir_path(__FILE__) . $relative_path));
+ $plugin_dir = plugin_dir_url(__FILE__);
+ echo "<script>
+ var plugin_path = '$plugin_dir';
+ </script>";
- wp_enqueue_script($prefix . "-" . $script_name . "-" . $type, plugins_url($relative_path, __FILE__), $dependencies, false);
+ require_once(__DIR__ . '/editor/editor.php');
}
-function ks_enqueue_style($relative_path, $dependencies = array())
+function ks_add_editor_dependencies()
{
- $prefix = "ks";
- $type = "style";
- $style_name = end(explode("/", $relative_path));
- $style_name = explode(".", $style_name)[0];
-
- for ($i = 0; $i < sizeof($dependencies); $i++) {
- $dependencies[$i] = $prefix . "-" . $dependencies[$i] . "-" . $type;
- }
+ $script_path = 'build' . DIRECTORY_SEPARATOR . $GLOBALS['build'] . DIRECTORY_SEPARATOR . 'graph.js';
- // Source: https://developer.wordpress.org/reference/functions/wp_enqueue_script/ a comment from Andrija Naglic
- $file_version = date("ymd-Gis", filemtime(plugin_dir_path(__FILE__) . $relative_path));
+ wp_enqueue_script('jquery');
+ wp_enqueue_script("ks-editor-js", plugins_url($script_path, __FILE__), array(), false);
- wp_enqueue_style($prefix . "-" . $style_name . "-" . $type, plugins_url($relative_path, __FILE__), $dependencies, $file_version);
+ $style_file_version = date("ymd-Gis", filemtime(plugin_dir_path(__FILE__) . "editor/css/editor.css"));
+ wp_enqueue_style("ks-editor-css", plugins_url("editor/css/editor.css", __FILE__), array(), $style_file_version);
}
function kg_load_css()
{
$plugin_dir = plugin_dir_url(__FILE__);
- wp_enqueue_style('kg-style', $plugin_dir.'kg-style.css');
+ wp_enqueue_style('kg-style', $plugin_dir . 'kg-style.css');
}
add_action('wp_enqueue_scripts', 'kg_load_css');
diff --git a/package.json b/package.json
index 016ab5ee92e72c049f99c8888977723b141b6f43..d855e30209554b32d05b3227a48d8a35ce56c70a 100644
--- a/package.json
+++ b/package.json
@@ -14,7 +14,11 @@
"distDir": "build/release/",
"sourceMap": false,
"optimize": true,
- "includeNodeModules": ["three", "3d-force-graph"],
+ "includeNodeModules": [
+ "three",
+ "3d-force-graph",
+ "force-graph"
+ ],
"isLibrary": true,
"context": "node"
}
@@ -45,6 +49,7 @@
},
"dependencies": {
"3d-force-graph": "^1.70.5",
+ "force-graph": "^1.42.2",
"jquery": "^3.6.0",
"three": "^0.131.2"
}