aud1v3.json

      "name": "Laufzeit von Algorithmus 2.7",
      "description": "Wir betrachten einmal die Laufzeit des Hierholzer-Algorithmus (2.7) und im Zusammenhang damit auch verkettete Listen.",
      "type": "Beispiel"
    },
    {
      "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.",
      "type": "Beispiel"
    },
    {
      "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.",
      "type": "Beispiel"
    },
    {
      "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",
      "type": "Vorlesung"
    },
    {
      "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.",
      "type": "Definition"
    },
    {
      "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.",
      "type": "Definition"
    },
    {
      "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.",
      "type": "Definition"
    },
    {
      "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",
      "type": "Vorlesung"
    },
    {
      "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.",
      "type": "Algorithmus"
    },
    {
      "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",
      "type": "Vorlesung"
    },
    {
      "id": 67,
      "name": "Permutation",
      "description": "Eine Permutation P ist eine Umsortierung von n Objekten.",
      "type": "Definition"
    },
    {
      "id": 68,
      "name": "Erzeugende Funktionen",
      "description": "Erzeugende Funktionen können genutzt werden um Rekursionen zu lösen.",
      "type": "Definition"
    },
    {
      "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",
      "type": "Vorlesung"
    },
    {
      "id": 70,
      "name": "erzeugende Funktionen Fibonacci-Zahlen",
      "description": "In diesem Beispiel wird einmal die erzeugende Funktion der Fibonacci-Zahlen hergeleitet.",
      "type": "Beispiel"
    },
    {
      "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.",
      "type": "Definition"
    },
    {
      "id": 72,
      "name": "Master-Theorem Beispiele",
      "description": "Einige Beispiele, an denen das Master-Theorem und seine Funktion noch einmal verdeutlicht wird.",
      "type": "Beispiel"
    },
    {
      "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",
      "type": "Übung"
    },
    {
      "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.",
      "type": "Beispiel"
    },
    {
      "id": 75,
      "name": "Master-Theorem Beispiel",
      "description": "3 weitere Beispiele, welche dabei helfen das Master-Theorem zu verstehen und anzuwenden.",
      "type": "Beispiel"
    },
    {
      "id": 76,
      "name": "Max-Heaps",
      "description": "Hier wir aufgezeigt, wie man mithilfe eines Algorithmus Max-Heaps bildet. ",
      "type": "Algorithmus"
    },
    {
      "id": 77,
      "name": "Max-Heaps",
      "description": "Hier wird der Algorithmus aus der Übung 6 zum Erstellen eines Max-Heaps einmal an einem Beispiel angewandt.",
      "type": "Beispiel"
    },
    {
      "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.",
      "type": "Algorithmus"
    },
    {
      "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",
      "type": "Vorlesung"
    },
    {
      "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.",
      "type": "Definition"
    },
    {
      "id": 81,
      "name": "Mandelbrot-Menge",
      "description": "Die Mandelbrot-Menge, benannt nach Benoît Mandelbrot, ist eine Menge in den komplexen Zahlen. Interpretiert man sie als geometrische Figur, so ergibt sich ein Fraktal, welches im allgemeinen Sprachgebrauch auch als Apfelmännchen bekannt ist.",
      "type": "Definition"
    },
    {
      "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",
      "type": "Definition"
    },
    {
      "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",
      "type": "Definition"
    },
    {
      "id": 84,
      "name": "Game of Life",
      "description": "Das \'Game of Life\' ist das wohl bekannteste Beispiel eines zellulären Automaten. ",
      "type": "Beispiel"
    },
    {
      "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",
      "type": "Vorlesung"
    },
    {
      "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.",
      "type": "Algorithmus"
    },
    {
      "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.",
      "type": "Beispiel"
    },
    {
      "id": 88,
      "name": "Mediane",
      "description": "In dieser Vorlesung beschäftigen wir uns mit Medianen.\\n+ Links zu Video und Folien",
      "type": "Vorlesung"
    },
    {
      "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.",
      "type": "Definition"
    },
    {
      "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.",
      "type": "Definition"
    },
    {
      "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.",
      "type": "Definition"
    },
    {
      "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",
      "type": "Vorlesung"
    },
    {
      "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].",
      "type": "Algorithmus"
    },
    {
      "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.",
      "type": "Algorithmus"
    },
    {
      "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",
      "type": "Übung"
    },
    {
      "id": 96,
      "name": "Quick-Sort Beispiel",
      "description": "In diesem Beispiel wird die Funktionsweise von Quick-Sort, sowie die Laufzeit betrachtet.",
      "type": "Beispiel"
    },
    {
      "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.",
      "type": "Beispiel"
    },
    {
      "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.",
      "type": "Definition"
    },
    {
      "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",
      "type": "Vorlesung"
    },
    {
      "id": 100,
      "name": "Bubble-Sort Beispiel",
      "description": "Einige Beispiele, wie Bubble-Sort funktioniert, inklusive einiger verschiedener Darstellungen/Animationen und dem Vergleich mit Quick-Sort.",
      "type": "Algorithmus"
    },
    {
      "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.",
      "type": "Definition"
    },
    {
      "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.",
      "type": "Algorithmus"
    },
    {
      "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",
      "type": "Vorlesung"
    },
    {
      "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",
      "type": "Übung"
    },
    {
      "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?",
      "type": "Kapitel"
    },
    {
      "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.",
      "type": "Kapitel"
    },
    {
      "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.",
      "type": "Kapitel"
    },
    {
      "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.",
      "type": "Kapitel"
    },
    {
      "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.",
      "type": "Kapitel"
    },
    {
      "id": 0,
      "name": "AuD1",
      "description": "Algorithmen und Datenstrukturen 1",
      "type": "Kapitel"
    }
  ],
  "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"
    },
    {