add code

_loesung_teil_A.md

@@ -0,0 +1,31 @@
+# Aufgabe 2
+## Teilaufgabe a)
+Erläuterung
+
+## Teilaufgabe b)
+Lösung als Liste angeben
+
+## Teilaufgabe c)
+Lösung auf dem Aufgabenblatt in der Zeichenfläche angeben!
+
+# Aufgabe 3
+## Teilaufgabe a) 
+
+
+## Teilaufgabe b)
+
+
+## Teilaufgabe c)
+Vorlage für die Adjazenzmatrix
+
+| - | - | - | - | - | - | - | - | - |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| - | - | - | - | - | - | - | - | - |
+| - | - | - | - | - | - | - | - | - |
+| - | - | - | - | - | - | - | - | - |
+| - | - | - | - | - | - | - | - | - |
+
+ggf. weitere Zeilen kopieren und einfügen
+
+## Teilaufgabe d)
+Begründung

_loesung_teil_B.md

@@ -0,0 +1,26 @@
+# Aufgabe 4
+## Teilaufgabe a)
+- ...
+- ...
+
+## Teilaufgabe b)
+Direkt im Quelltext einfügen.
+
+## Teilaufgabe c)
+Direkt im Quelltext einfügen.
+
+## Teilaufgabe d)
+Textform oder Verweis auf die Datei mit der Abbildung.
+
+# Aufgabe 5
+## Teilaufgabe a)
+Verweis auf die Datei mit der Abbildung
+
+## Teilaufgabe b)
+Direkt im Quelltext aufgabe5.py einfügen.
+
+## Teilaufgabe c)
+Direkt im Quelltext aufgabe5.py einfügen.
+
+## Teilaufgabe d1) oder d2)
+Direkt im Quelltext aufgabe5.py einfügen.

aufgabe5.py

@@ -0,0 +1 @@
+# Hier Quellcode einfügen.

graph.py

@@ -0,0 +1,100 @@
+class Knoten(object):
+    def __init__(self, nameKnoten):
+        self.name = nameKnoten
+        self.kantenZuNachbarn = []
+
+    def addNachbar(self, refKante):
+        self.kantenZuNachbarn = self.kantenZuNachbarn + [(refKante)]
+
+    def delNachbar(self, refKante):
+        neueListe = []
+        for kante in self.kantenZuNachbarn:
+            if kante != refKante:
+                neueListe = neueListe + [kante]
+        self.kantenZuNachbarn = neueListe
+
+
+class Kante(object):
+    def __init__(self, refStartKnoten, refZielKnoten):
+        self.startKnoten = refStartKnoten
+        self.zielKnoten = refZielKnoten
+
+
+class Graph(object):
+    def __init__(self):
+        self.knotenListe = []
+
+    def getRefKnoten(self, nameKnoten):
+        refKnoten = None
+        for knoten in self.knotenListe:
+            if knoten.name == nameKnoten:
+                refKnoten = knoten
+        return refKnoten
+
+    def addKnoten(self, nameKnoten):
+        refKnoten = self.getRefKnoten(nameKnoten)
+        if refKnoten == None:
+            knoten = Knoten(nameKnoten)
+            self.knotenListe = self.knotenListe + [knoten]
+
+    def delKnoten(self, nameKnoten):
+        neueListe = []
+        for knoten in self.knotenListe:
+            if knoten.name != nameKnoten:
+                neueListe = neueListe + [knoten]
+                neueNachbarn = []
+                for kante in knoten.kantenZuNachbarn:
+                    if kante.zielKnoten.name != nameKnoten:
+                        neueNachbarn = neueNachbarn + [kante]
+                knoten.kantenZuNachbarn = neueNachbarn
+        self.knotenListe = neueListe
+
+    def addKante(self, nameStartKnoten, nameZielKnoten):
+        if self.existiertKnoten(nameStartKnoten) and \
+                self.existiertKnoten(nameZielKnoten) and \
+                not self.existiertKante(nameStartKnoten, nameZielKnoten):
+            refStartKnoten = self.getRefKnoten(nameStartKnoten)
+            refZielKnoten = self.getRefKnoten(nameZielKnoten)
+            if refStartKnoten != None and refZielKnoten != None:
+                neueKante = Kante(refStartKnoten, refZielKnoten)
+                refStartKnoten.addNachbar(neueKante)
+
+    def delKante(self, nameStartKnoten, nameZielKnoten):
+        for knoten in self.knotenListe:
+            if knoten.name == nameStartKnoten:
+                for kante in knoten.kantenZuNachbarn:
+                    if kante.zielKnoten.name == nameZielKnoten:
+                        knoten.delNachbar(kante)
+
+    def getAlleKnoten(self):
+        namenKnoten = []
+        for knoten in self.knotenListe:
+            namenKnoten = namenKnoten + [knoten.name]
+        return namenKnoten
+
+    def getAlleNachbarn(self, nameKnoten):
+        refKnoten = self.getRefKnoten(nameKnoten)
+        if refKnoten != None:
+            listeNachbarn = []
+            for kante in refKnoten.kantenZuNachbarn:
+                listeNachbarn = listeNachbarn + [kante.zielKnoten.name]
+            return listeNachbarn
+        else:
+            return []
+
+    def existiertKnoten(self, nameKnoten):
+        if self.getRefKnoten(nameKnoten) == None:
+            return False
+        else:
+            return True
+
+    def existiertKante(self, nameStartKnoten, nameZielKnoten):
+        gefunden = False
+        refStartKnoten = self.getRefKnoten(nameStartKnoten)
+        refZielKnoten = self.getRefKnoten(nameZielKnoten)
+        if refStartKnoten != None and refZielKnoten != None:
+            for kante in refStartKnoten.kantenZuNachbarn:
+                if kante.zielKnoten == refZielKnoten:
+                    gefunden = True
+        return gefunden
+

list.py

@@ -0,0 +1,158 @@
+class Element:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+    # Rekursive Methode zur Berechnung der Länge der Liste
+    def length(self):
+        if self.next is None:
+            return 1
+        else:
+            return 1 + self.next.length()
+
+    # Entfernt iterativ das erste gefundene Elemente mit dem Wert value aus der Liste
+    def remove(self,value):
+        previous = self
+        current = self.next
+        while current is not None:
+            if current.data == value:
+                previous.next = current.next
+            previous = previous.next
+            current = current.next
+
+    # Rekursive Methode zur Entfernung des letzten Elements
+    def remove_last(self):
+        if self.next.next is not None:
+            self.next.remove_last()
+        else:
+            self.next = None
+
+
+class Liste:
+    def __init__(self):
+        self.head = None
+
+    # Einfügen eines Elements mit Wert value am Anfang der Liste
+    def insert(self, value):
+        new_element = Element(value)
+        new_element.next = self.head
+        self.head = new_element
+
+    # Entfernt das erste Element aus der Liste
+    def remove_first(self):
+        if self.head is not None:
+            value = self.head.data
+            self.head = self.head.next
+            return value
+
+    # Methode zur Darstellung der Liste
+    def show_list(self):
+        current = self.head
+        while current is not None:
+            print(current.data)
+            current = current.next
+        print("---")
+
+    # Bestimmt rekursiv die Länge der Liste
+    def length(self):
+        if self.head is None:
+            return 0
+        else:
+            return self.head.length()
+
+    # Sucht nach einem Element mit dem Wert value und gibt den Wert zurück
+    def search(self, value):
+        current = self.head
+        while current is not None:
+            if current.data == value:
+                return current
+            current = current.next
+        return None
+
+    # Fügt ein Element mit Wert value vor einem Element mit Wert compValue ein
+    def insert_before(self, value, comp_value):
+        new_element = Element(value)
+        if self.head is None:
+            return
+        if self.head.data == comp_value:
+            new_element.next = self.head
+            self.head = new_element
+            return
+        current = self.head
+        while current.next is not None and current.next.data != comp_value:
+            current = current.next
+        if current.next is not None:
+            new_element.next = current.next
+            current.next = new_element
+
+    # Rekursive Methode zur Entfernung des letzten Elements
+    def remove_last(self):
+        if self.head is not None:
+            if self.head.next is not None:
+                self.head.remove_last()
+            else:
+                self.head = None
+
+    # Iterative Methode zur Entfernung des letzten Elements
+    def remove_last2(self):
+        current = self.head
+        if current is None:
+            return
+        elif current.next is None:
+            self.head = None
+            return
+        else:
+            previous = self.head
+            current = current.next
+            while current.next is not None:
+                previous = current
+                current = current.next
+            previous.next = None
+            return
+
+    # Rekursive Methode zur Entfernung eines Elements mit Wert value
+    def remove(self,value):
+        if self.head is None:
+            return
+        if self.head.data == value:
+            self.head = self.head.next
+        else:
+            self.head.remove(value)
+
+    # Iterative Methode zur Entfernung eines Elements mit Wert value
+    def remove2(self, value):
+        if self.head is None:
+            return
+        if self.head.data == value:
+            self.head = self.head.next
+            return
+        previous = self.head
+        current = previous.next
+        while current is not None:
+            if current.data == value:
+                previous.next = current.next
+                return
+            previous = previous.next
+            current = current.next
+
+    # Sortiert rekursiv eine Liste nachträglich
+    def sub_sort(self):
+        if self.head is not None:
+            value = self.remove_first()
+            self.sub_sort()
+            self.insert_sorted(value)
+
+    # Hilfsfunktion zu sub_sort, welches ein neues Element mit Wert value sortiert in eine bestehende Liste einsortiert
+    def insert_sorted(self, value):
+        new_element = Element(value)
+        if self.head is None:
+            self.head = new_element
+        elif self.head.data > value:
+            new_element.next = self.head
+            self.head = new_element
+        else:
+            current = self.head
+            while current.next is not None and current.next.data < value:
+                current = current.next
+            new_element.next = current.next
+            current.next = new_element

queue.py

@@ -0,0 +1,44 @@
+class Element:
+    def __init__(self, data, prev, next):
+        self.data = data
+        self.prev = prev
+        self.next = next
+
+
+class Queue2:
+    def __init__(self):
+        self.butt = None
+        self.head = None
+
+    def isEmpty(self):
+        if self.butt is None and self.head is None:
+            return True
+        else:
+            return False
+
+    def showQueue(self):
+        print(f"QUEUE head: {self.head}, butt: {self.butt}")
+        current = self.head
+        while current is not None:
+            print(f"Data: {current.data}")
+            current = current.next
+        print("----")
+
+    def enqueue(self, data):
+        newElement = Element(data, self.butt, None)
+        self.butt = newElement
+        if self.head is None:
+            self.head = newElement
+        else:
+            current = self.head
+            while current.next is not None:
+                current = current.next
+            current.next = newElement
+
+    def dequeue(self):
+        if self.head is not None:
+            ausgabe = self.head.data
+            self.head = self.head.next
+            if self.head is None:
+                self.butt = None
+            return ausgabe

tree.py

@@ -0,0 +1,158 @@
+class Node:
+    def __init__(self, value):
+        self.value = value  # Wert des Knotens
+        self.left = None    # Linkes Kind
+        self.right = None   # Rechtes Kind
+
+    # Fügt rekursiv ein neues Element mit dem Wert value in den Baum ein
+    def insert(self, value):
+        if self.value == value:
+            return print("Die Daten existieren schon.")
+        else:
+            if self.value > value:
+                if self.left is not None:
+                    return self.left.insert(value)
+                else:
+                    self.left = Node(value)
+            else:
+                if self.right is not None:
+                    return self.right.insert(value)
+                else:
+                    self.right = Node(value)
+
+    # Methode zur Darstellung des Baums
+    def show(self, level):
+        if self.left is not None:
+            self.left.show(level + 1)
+        print(' ' * 4 * level + "->" + str(self.value))
+        if self.right is not None:
+            self.right.show(level + 1)
+
+    # Sucht ein Element mit dem Wert value im Baum
+    def search(self, value):
+        if self.value == value:
+            return True
+        elif self.value > value:
+            if self.left is not None:
+                return self.left.search(value)
+        else:
+            if self.right is not None:
+                return self.right.search(value)
+
+    # Zählt die Anzahl der Elemente im Baum
+    def count(self):
+        count = 1
+        if self.left is not None:
+            count += self.left.count()
+        if self.right is not None:
+            count += self.right.count()
+        return count
+
+    # Löscht ein Element mit dem Wert value aus dem Baum
+    def delete(self, value):
+        if value < self.value:
+            if self.left is not None:
+                self.left = self.left.delete(value)
+        elif value > self.value:
+            if self.right is not None:
+                self.right = self.right.delete(value)
+        else:
+            if self.left is None:
+                return self.right
+            elif self.right is None:
+                return self.left
+            else:
+                min_larger_node = self.right
+                while min_larger_node.left is not None:
+                    min_larger_node = min_larger_node.left
+                self.value = min_larger_node.value
+                self.right = self.right.delete(min_larger_node.value)
+        return self
+
+    # Gibt die Elemente des Baums in einer Liste (preorder) aus
+    def treeToList(self, output):
+        output.append(self.value)
+        if self.left is not None:
+            self.left.treeToList(output)
+        if self.right is not None:
+            self.right.treeToList(output)
+        return output
+
+    # Sucht das kleinste Element im Baum
+    def min(self):
+        if self.left is not None:
+            return self.left.min()
+        else:
+            return self.value
+
+
+class Tree:
+    def __init__(self):
+        self.root = None  # Wurzel des Baums
+
+    # Fügt rekursiv ein neues Element mit dem Wert value in den Baum ein
+    def insert(self, value):
+        if self.root is None:
+            self.root = Node(value)
+        else:
+            return self.root.insert(value)
+
+    # Methode zur Darstellung des Baums
+    def show(self):
+        if self.root is not None:
+            self.root.show(0)
+        else:
+            print("Baum ist leer")
+
+    # Sucht ein Element mit dem Wert value im Baum
+    def search(self, value):
+        if self.root is not None:
+            print(f"gesuchter Knoten: {self.root.search(value)}")
+        else:
+            print("gesuchter Knoten: Baum ist leer")
+
+    # Zählt die Anzahl der Elemente im Baum
+    def count(self):
+        if self.root is not None:
+            print(f"Anzahl Knoten: {self.root.count()}")
+        else:
+            print("Anzahl Knoten: 0")
+
+    # Löscht ein Element mit dem Wert value aus dem Baum
+    def delete(self, value):
+        if self.root is not None:
+            self.root = self.root.delete(value)
+        else:
+            print("Baum ist leer, nichts zu löschen.")
+
+    # Gibt die Elemente des Baums in einer Liste (preorder) aus
+    def treeToList(self):
+        output = []
+        if self.root is not None:
+            return self.root.treeToList(output)
+        else:
+            return []
+
+    # Erzeugt rekursiv einen neuen Baum aus den Elementen einer Liste
+    def createTree(self, list):
+        if list:
+            mid = len(list)//2
+            self.insert(list[mid])
+            self.createTree(list[:mid])
+            self.createTree(list[mid+1:])
+
+    # Sucht das kleinste Element im Baum
+    def min(self):
+        if self.root is not None:
+            return print(f"Kleinstes Element: {self.root.min()}")
+        else:
+            return print("Kleinstes Element: Baum ist leer")
+
+b = Tree()
+b.insert(4)
+b.insert(7)
+b.insert(2)
+b.insert(8)
+b.insert(3)
+b.insert(1)
+print(b.treeToList())