Init

vorlesung/L05_binaere_baeume/__init__.py

@@ -0,0 +1 @@
+from vorlesung.L05_binaere_baeume.bin_tree import BinaryTree

vorlesung/L05_binaere_baeume/analyze_avl_tree.py

@@ -0,0 +1,26 @@
+from utils.memory_manager import MemoryManager
+from utils.memory_array import MemoryArray
+from utils.literal import Literal
+from vorlesung.L05_binaere_baeume.avl_tree import AVLTree
+
+def analyze_complexity(sizes):
+    """
+    Analysiert die Komplexität
+
+    :param sizes: Eine Liste von Eingabegrößen für die Analyse.
+    """
+    for size in sizes:
+        MemoryManager.purge()  # Speicher zurücksetzen
+        tree = AVLTree()
+        random_array = MemoryArray.create_random_array(size, -100, 100)
+        for i in range(size-1):
+            tree.insert(int(random_array[Literal(i)]))
+        MemoryManager.reset()
+        tree.insert(int(random_array[Literal(size-1)]))
+        MemoryManager.save_stats(size)
+
+    MemoryManager.plot_stats(["cells", "compares"])
+
+if __name__ == "__main__":
+    sizes = range(1, 1001, 2)
+    analyze_complexity(sizes)

vorlesung/L05_binaere_baeume/analyze_binary_tree.py

@@ -0,0 +1,26 @@
+from utils.memory_manager import MemoryManager
+from utils.memory_array import MemoryArray
+from utils.literal import Literal
+from vorlesung.L05_binaere_baeume.bin_tree import BinaryTree
+
+def analyze_complexity(sizes):
+    """
+    Analysiert die Komplexität
+
+    :param sizes: Eine Liste von Eingabegrößen für die Analyse.
+    """
+    for size in sizes:
+        MemoryManager.purge()  # Speicher zurücksetzen
+        tree = BinaryTree()
+        random_array = MemoryArray.create_random_array(size, -100, 100)
+        for i in range(size-1):
+            tree.insert(int(random_array[Literal(i)]))
+        MemoryManager.reset()
+        tree.insert(int(random_array[Literal(size-1)]))
+        MemoryManager.save_stats(size)
+
+    MemoryManager.plot_stats(["cells", "compares"])
+
+if __name__ == "__main__":
+    sizes = range(1, 1001, 2)
+    analyze_complexity(sizes)

vorlesung/L05_binaere_baeume/avl_tree.py

@@ -0,0 +1,94 @@
+from utils.memory_array import MemoryArray
+from vorlesung.L05_binaere_baeume.avl_tree_node import AVLTreeNode
+from vorlesung.L05_binaere_baeume.bin_tree import BinaryTree
+import logging
+
+class AVLTree(BinaryTree):
+
+    def __init__(self):
+        super().__init__()
+
+    def new_node(self, value):
+        return AVLTreeNode(value)
+
+
+    def balance(self, node: AVLTreeNode):
+        node.update_balance()
+        if node.balance == -2:
+            if node.left.balance <= 0:
+                node = node.right_rotate()
+            else:
+                node = node.left_right_rotate()
+        elif node.balance == 2:
+            if node.right.balance >= 0:
+                node = node.left_rotate()
+            else:
+                node = node.right_left_rotate()
+        if node.parent:
+            self.balance(node.parent)
+        else:
+            self.root = node
+
+    def insert(self, value):
+        insert_generator = self.insert_stepwise(value)
+        node, parent = None, None
+        while True:
+            try:
+                node, parent = next(insert_generator)
+            except StopIteration:
+                break
+        return node, parent
+
+    def insert_stepwise(self, value):
+        node, parent = super().insert(value)
+        yield None, None
+        node.parent = parent
+        if parent:
+            self.balance(parent)
+        return node, parent
+
+
+    def delete(self, value):
+        node, parent = super().delete(value)
+        if node:
+            node.parent = parent
+        if parent:
+            self.balance(parent)
+
+    def graph_filename(self):
+        return "AVLTree"
+
+if __name__ == "__main__":
+
+    def print_node(node, indent=0, level=0):
+        print((indent * 3) * " ", node.value)
+
+    tree = AVLTree()
+    #values = [5, 3, 7, 2, 4, 6, 5, 8]
+    values = MemoryArray.create_array_from_file("data/seq2.txt")
+
+    for value in values:
+        tree.insert(value)
+
+
+    print("In-order traversal:")
+    tree.in_order_traversal(print_node)
+    print("\nLevel-order traversal:")
+    tree.level_order_traversal(print_node)
+    print("\nTree structure traversal:")
+    tree.tree_structure_traversal(print_node)
+    print("\nGraph traversal:")
+    tree.graph_traversal()
+
+    tree.insert(9)
+    tree.graph_traversal()
+
+    print("\nDeleting 5:")
+    tree.delete(5)
+
+    print("In-order traversal after deletion:")
+    tree.in_order_traversal(print_node)
+    print("\nLevel-order traversal after deletion:")
+    tree.level_order_traversal(print_node)
+    print("\nTree structure traversal after deletion:")
+    tree.tree_structure_traversal(print_node)

vorlesung/L05_binaere_baeume/avl_tree_game.py

@@ -0,0 +1,59 @@
+import random
+import pygame
+from utils.game import Game
+from avl_tree import AVLTree
+
+WHITE = (255, 255, 255)
+BLUE = (0, 0, 255)
+BLACK = (0, 0, 0)
+WIDTH = 800
+HEIGHT = 400
+MARGIN = 20
+
+class AVLTreeGame(Game):
+
+    def __init__(self):
+        super().__init__("AVLTree Game", fps=10, size=(WIDTH, HEIGHT))
+        random.seed()
+        self.z = list(range(1, 501))
+        random.shuffle(self.z)
+        self.finished = False
+        self.tree = AVLTree()
+        self.tree.get_height = lambda node: 0 if node is None else 1 + max(self.tree.get_height(node.left), self.tree.get_height(node.right))
+        self.height = self.tree.get_height(self.tree.root)
+        self.generator = None
+
+    def update_game(self):
+        if not self.finished:
+            if self.generator is None:
+                self.generator = self.tree.insert_stepwise(self.z.pop())
+            try:
+                next(self.generator)
+            except StopIteration:
+                self.generator = None
+            if self.generator is None and len(self.z) == 0:
+                self.finished = True
+            self.height = self.tree.get_height(self.tree.root)
+        return True
+
+    def draw_game(self):
+        self.screen.fill(WHITE)
+        if self.height > 0:
+            self.draw_tree(self.tree.root, WIDTH // 2, MARGIN, WIDTH // 4 - MARGIN)
+        super().draw_game()
+
+    def draw_tree(self, node, x, y, x_offset):
+        y_offset = (HEIGHT - (2 * MARGIN)) / self.height
+        if node is not None:
+            pygame.draw.circle(self.screen, BLUE, (x, y), 2)
+            if node.left is not None:
+                pygame.draw.line(self.screen, BLACK, (x, y), (x - x_offset, y + y_offset))
+                self.draw_tree(node.left, x - x_offset, y + y_offset, x_offset // 2)
+            if node.right is not None:
+                pygame.draw.line(self.screen, BLACK, (x, y), (x + x_offset, y + y_offset))
+                self.draw_tree(node.right, x + x_offset, y + y_offset, x_offset // 2)
+
+if __name__ == "__main__":
+    tree_game = AVLTreeGame()
+    tree_game.run()
+

vorlesung/L05_binaere_baeume/avl_tree_node.py

@@ -0,0 +1,61 @@
+from vorlesung.L05_binaere_baeume.bin_tree_node import BinaryTreeNode
+
+class AVLTreeNode(BinaryTreeNode):
+    def __init__(self, value):
+        super().__init__(value)
+        self.parent = None
+        self.balance = 0
+
+    def __repr__(self):
+        return f"TreeNode(id={id(self)} value={self.value}, left={self.left}, right={self.right})"
+
+    def graphviz_rep(self, row, col, dot):
+        dot.node(str(id(self)), label=str(self.value), pos=f"{col},{-row}!", xlabel=str(self.balance))
+
+    def update_balance(self):
+        left_height = self.left.height() if self.left else 0
+        right_height = self.right.height() if self.right else 0
+        self.balance = right_height - left_height
+
+    def right_rotate(self):
+        new_root = self.left
+        new_root.parent = self.parent
+        self.left = new_root.right
+        if self.left:
+            self.left.parent = self
+        new_root.right = self
+        self.parent = new_root
+        if new_root.parent:
+            if new_root.parent.left is self:
+                new_root.parent.left = new_root
+            else:
+                new_root.parent.right = new_root
+        self.update_balance()
+        new_root.update_balance()
+        return new_root
+
+    def left_rotate(self):
+        new_root = self.right
+        new_root.parent = self.parent
+        self.right = new_root.left
+        if self.right:
+            self.right.parent = self
+        new_root.left = self
+        self.parent = new_root
+        if new_root.parent:
+            if new_root.parent.left is self:
+                new_root.parent.left = new_root
+            else:
+                new_root.parent.right = new_root
+        self.update_balance()
+        new_root.update_balance()
+        return new_root
+
+    def right_left_rotate(self):
+        self.right = self.right.right_rotate()
+        return self.left_rotate()
+
+    def left_right_rotate(self):
+        self.left = self.left.left_rotate()
+        return self.right_rotate()
+

vorlesung/L05_binaere_baeume/bin_search.py

@@ -0,0 +1,61 @@
+import random
+
+from utils.memory_array import MemoryArray
+from utils.memory_cell import MemoryCell
+from utils.memory_manager import MemoryManager
+from utils.memory_range import mrange
+from utils.literal import Literal
+
+
+def binary_search(z: MemoryArray, s: MemoryCell, l: Literal = None, r: Literal = None):
+    """
+    Perform a binary search on the sorted array z for the value x.
+    """
+    if l is None:
+        l = Literal(0)
+    if r is None:
+        r = Literal(z.length().pred())
+    if l > r:
+        return None
+    with MemoryCell(l) as m:
+        m += r
+        m //= Literal(2)
+        if s < z[m]:
+            return binary_search(z, s, l, m.pred())
+        elif s > z[m]:
+            return binary_search(z, s, m.succ(), r)
+        else:
+            return m
+
+
+def analyze_complexity(sizes):
+    """
+    Analysiert die Komplexität
+
+    :param sizes: Eine Liste von Eingabegrößen für die Analyse.
+    """
+    for size in sizes:
+        MemoryManager.purge()  # Speicher zurücksetzen
+        random_array = MemoryArray.create_sorted_array(size)
+        search_value = random.randint(-100, 100)
+        binary_search(random_array, MemoryCell(search_value))
+        MemoryManager.save_stats(size)
+
+    MemoryManager.plot_stats(["cells", "compares", "adds"])
+
+
+
+
+if __name__ == "__main__":
+    # Example usage
+    arr = MemoryArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    search_value = MemoryCell(8)
+    result = binary_search(arr, search_value)
+    if result is not None:
+        print(f"Value {search_value} found at index {result}.")
+    else:
+        print(f"Value {search_value} not found in the array.")
+
+
+    sizes = range(1, 1001, 2)
+    analyze_complexity(sizes)

vorlesung/L05_binaere_baeume/bin_tree.py

@@ -0,0 +1,206 @@
+from vorlesung.L05_binaere_baeume.bin_tree_node import BinaryTreeNode
+from utils.project_dir import get_path
+from datetime import datetime
+import graphviz
+
+
+class BinaryTree:
+
+    def __init__(self):
+        self.root = None
+        self.size = 0
+
+    def new_node(self, value):
+        return BinaryTreeNode(value)
+
+    def insert(self, value):
+        self.size += 1
+        value = self.new_node(value)
+        if self.root is None:
+            self.root = value
+            return self.root, None
+        else:
+            current = self.root
+            while True:
+                if value < current:
+                    if current.left:
+                        current = current.left
+                    else:
+                        current.left = value
+                        return current.left, current
+                elif value >= current:
+                    if current.right:
+                        current = current.right
+                    else:
+                        current.right = value
+                        return current.right, current
+                else:
+                    return None, None
+
+    def search(self, value):
+        current = self.root
+        value = self.new_node(value)
+        while current:
+            if value < current:
+                current = current.left
+            elif value > current:
+                current = current.right
+            else:
+                return current
+        return None
+
+    def delete(self, value):
+        # Der Wert wird im Baum gesucht und der erste Treffer gelöscht
+        # Rückgabe falls der Wert gefunden wird:
+        # der Knoten, der den zu löschenden Knoten ersetzt und der Elternknoten des gelöschten Knotens
+        parent = None
+        current = self.root
+        value = self.new_node(value)
+        while current:
+            if value < current:
+                parent = current
+                current = current.left
+            elif value > current:
+                parent = current
+                current = current.right
+            else:
+                # Knoten gefunden
+                break
+        else:
+            # Wert nicht gefunden
+            return None, None
+        return self.delete_node(current, parent)
+
+    def delete_node(self, current, parent):
+        # Der übergebene Knoten wird
+        # Rückgabe ist ein Tupel:
+        # der Knoten, der den zu löschenden Knoten ersetzt und der Elternknoten des gelöschten Knotens
+        self.size -= 1
+        # Fall 3: Es gibt zwei Kinder: wir suchen den Nachfolger
+        if current.left and current.right:
+            parent = current
+            successor = current.right
+            while successor.left:
+                parent = successor
+                successor = successor.left
+            # Wert des Nachfolgers wird in den Knoten geschrieben, der gelöscht werden soll
+            current.value = successor.value
+            # Ab jetzt muss successor gelöscht werden; parent ist bereits richtig gesetzt
+            current = successor
+
+        # Ermitteln des einen Kindes (falls es eines gibt), sonst None
+        # Das eine Kind ist der Ersatz für den Knoten, der gelöscht werden soll
+        if current.left:
+            child = current.left
+        else:
+            child = current.right
+
+        # Falls es keinen Elternknoten gibt, ist der Ersatzknoten die Wurzel
+        if not parent:
+            self.root = child
+            return child, None
+        elif parent.left is current:
+            parent.left = child
+            return child, parent
+        else:
+            parent.right = child
+            return child, parent
+
+
+    def in_order_traversal(self, callback):
+
+        def in_order_traversal_recursive(callback, current):
+            if current is not None:
+                in_order_traversal_recursive(callback, current.left)
+                callback(current)
+                in_order_traversal_recursive(callback, current.right)
+
+        in_order_traversal_recursive(callback, self.root)
+
+
+    def level_order_traversal(self, callback):
+        if self.root is None:
+            return
+        queue = [(self.root, 0)]
+        while queue:
+            current, level = queue.pop(0)
+            callback(current, level)
+            if current.left is not None:
+                queue.append((current.left, level + 1))
+            if current.right is not None:
+                queue.append((current.right, level + 1))
+
+    def tree_structure_traversal(self, callback):
+
+        def tree_structure_traversal_recursive(callback, current, level):
+            nonlocal line
+            if current:
+                tree_structure_traversal_recursive(callback, current.left, level + 1)
+                callback(current, level, line)
+                line += 1
+                tree_structure_traversal_recursive(callback, current.right, level + 1)
+
+        line = 0
+        tree_structure_traversal_recursive(callback, self.root, 0)
+
+    def graph_filename(self):
+        return "BinaryTree"
+
+    def graph_traversal(self):
+        def define_node(node, level, line):
+            nonlocal dot
+            if node is not None:
+                node.graphviz_rep(level, line, dot)
+
+        def graph_traversal_recursive(current):
+            nonlocal dot
+            if current is not None:
+                if current.left:
+                    dot.edge(str(id(current)), str(id(current.left)))
+                    graph_traversal_recursive(current.left)
+                if current.right:
+                    dot.edge(str(id(current)), str(id(current.right)))
+                    graph_traversal_recursive(current.right)
+
+        dot = graphviz.Digraph( name="BinaryTree",
+                                engine="neato",
+                                node_attr={"shape": "circle", "fontname": "Arial"},
+                                format="pdf" )
+        self.tree_structure_traversal(define_node)
+        graph_traversal_recursive(self.root)
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{self.graph_filename()}_{timestamp}.gv"
+        filename = get_path(filename)
+        dot.render(filename)
+
+if __name__ == "__main__":
+    tree = BinaryTree()
+    values = [5, 3, 7, 2, 4, 6, 5, 8]
+
+    for value in values:
+        tree.insert(value)
+
+    def print_node(node, indent=0, line=None):
+        print((indent * 3) * " ", node.value)
+
+
+    print("In-order traversal:")
+    tree.in_order_traversal(print_node)
+    print("\nLevel-order traversal:")
+    tree.level_order_traversal(print_node)
+    print("\nTree structure traversal:")
+    tree.tree_structure_traversal(print_node)
+    print("\nGraph traversal:")
+    tree.graph_traversal()
+
+    print("\nDeleting 5:")
+    tree.delete(5)
+
+    print("In-order traversal after deletion:")
+    tree.in_order_traversal(print_node)
+    print("\nLevel-order traversal after deletion:")
+    tree.level_order_traversal(print_node)
+    print("\nTree structure traversal after deletion:")
+    tree.tree_structure_traversal(print_node)
+
+

vorlesung/L05_binaere_baeume/bin_tree_game.py

@@ -0,0 +1,54 @@
+import random
+import pygame
+from utils.game import Game
+from bin_tree import BinaryTree
+
+WHITE = (255, 255, 255)
+BLUE = (0, 0, 255)
+BLACK = (0, 0, 0)
+WIDTH = 800
+HEIGHT = 400
+MARGIN = 20
+
+class BinTreeGame(Game):
+
+    def __init__(self):
+        super().__init__("BinTree Game", fps=10, size=(WIDTH, HEIGHT))
+        random.seed()
+        self.z = list(range(1, 101))
+        random.shuffle(self.z)
+        self.finished = False
+        self.tree = BinaryTree()
+        self.tree.get_height = lambda node: 0 if node is None else 1 + max(self.tree.get_height(node.left), self.tree.get_height(node.right))
+        self.height = self.tree.get_height(self.tree.root)
+
+    def update_game(self):
+        if not self.finished:
+            i = self.z.pop()
+            self.tree.insert(i)
+            self.height = self.tree.get_height(self.tree.root)
+            if len(self.z) == 0:
+                self.finished = True
+        return True
+
+    def draw_game(self):
+        self.screen.fill(WHITE)
+        if self.height > 0:
+            self.draw_tree(self.tree.root, WIDTH // 2, MARGIN, WIDTH // 4 - MARGIN)
+        super().draw_game()
+
+    def draw_tree(self, node, x, y, x_offset):
+        y_offset = (HEIGHT - (2 * MARGIN)) / self.height
+        if node is not None:
+            pygame.draw.circle(self.screen, BLUE, (x, y), 2)
+            if node.left is not None:
+                pygame.draw.line(self.screen, BLACK, (x, y), (x - x_offset, y + y_offset))
+                self.draw_tree(node.left, x - x_offset, y + y_offset, x_offset // 2)
+            if node.right is not None:
+                pygame.draw.line(self.screen, BLACK, (x, y), (x + x_offset, y + y_offset))
+                self.draw_tree(node.right, x + x_offset, y + y_offset, x_offset // 2)
+
+if __name__ == "__main__":
+    tree_game = BinTreeGame()
+    tree_game.run()
+

vorlesung/L05_binaere_baeume/bin_tree_node.py

@@ -0,0 +1,22 @@
+from utils.memory_cell import MemoryCell
+
+class BinaryTreeNode(MemoryCell):
+
+    def __init__(self, value):
+        super().__init__(value)
+        self.left = None
+        self.right = None
+
+    def height(self):
+        left_height = self.left.height() if self.left else 0
+        right_height = self.right.height() if self.right else 0
+        return 1 + max(left_height, right_height)
+
+    def __repr__(self):
+        return f"TreeNode(value={self.value}, left={self.left}, right={self.right})"
+
+    def __str__(self):
+        return str(self.value)
+
+    def graphviz_rep(self, row, col, dot):
+        dot.node(str(id(self)), label=str(self.value), pos=f"{col},{-row}!")