requirements.txt

@@ -1,4 +1,3 @@
 matplotlib
 numpy
 pygame
-graphviz

vorlesung/L05_binaere_baeume/avl_tree.py

@@ -1,6 +1,6 @@
 from vorlesung.L05_binaere_baeume.avl_tree_node import AVLTreeNode
 from vorlesung.L05_binaere_baeume.bin_tree import BinaryTree
-import logging
+
 
 class AVLTree(BinaryTree):
 
@@ -27,26 +27,15 @@ class AVLTree(BinaryTree):
             self.balance(node.parent)
         else:
             self.root = node
+        # self.check_circle(self.root)
 
     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:

vorlesung/L05_binaere_baeume/avl_tree_game.py

@@ -1,59 +0,0 @@
-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/bin_tree_game.py

@@ -1,54 +0,0 @@
-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/L06_b_baeume/analyze_b_tree.py

@@ -1,58 +0,0 @@
-from utils.memory_manager import MemoryManager
-from utils.memory_array import MemoryArray
-from utils.literal import Literal
-from b_tree import BTree
-from b_tree_node import BTreeNode
-
-class MemoryManagerBTree(MemoryManager):
-    """
-    Diese Klasse erweitert den MemoryManager, um spezifische Statistiken für B-Bäume zu speichern.
-    """
-
-    @staticmethod
-    def count_loads():
-        return sum([cell.loaded_count for cell in MemoryManager().cells if isinstance(cell, BTreeNode)])
-
-    @staticmethod
-    def count_saves():
-        return sum([cell.saved_count for cell in MemoryManager().cells if isinstance(cell, BTreeNode)])
-
-    @staticmethod
-    def save_stats(count):
-        data = {    "cells": MemoryManager.count_cells(),
-                    "reads": MemoryManager.count_reads(),
-                    "writes": MemoryManager.count_writes(),
-                    "compares": MemoryManager.count_compares(),
-                    "adds": MemoryManager.count_adds(),
-                    "subs": MemoryManager.count_subs(),
-                    "muls": MemoryManager.count_muls(),
-                    "divs": MemoryManager.count_divs(),
-                    "bitops": MemoryManager.count_bitops(),
-                    "loads": MemoryManagerBTree.count_loads(),
-                    "saves": MemoryManagerBTree.count_saves()  }
-        MemoryManager.stats[count] = data
-
-
-
-
-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 = BTree(5)
-        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)]))
-        MemoryManagerBTree.save_stats(size)
-
-    MemoryManager.plot_stats(["cells", "compares", "loads", "saves"])
-
-if __name__ == "__main__":
-    sizes = range(1, 1001, 2)
-    analyze_complexity(sizes)