forked from hofmannol/AlgoDatSoSe25
294 lines
11 KiB
Python
294 lines
11 KiB
Python
import logging
|
|
logger = logging.getLogger(__name__)
|
|
# logging.basicConfig(level=logging.DEBUG)
|
|
|
|
import time
|
|
|
|
def timeMS(func, *args, **kwargs):
|
|
startTime = time.perf_counter()
|
|
result = func(*args, **kwargs)
|
|
endTime = time.perf_counter()
|
|
elapsedMS = (endTime - startTime) * 1000 # Convert to milliseconds
|
|
print(f"{func.__name__} took {elapsedMS:.2f} ms")
|
|
return result
|
|
|
|
|
|
from utils.memory_array import MemoryArray
|
|
from utils.memory_cell import MemoryCell
|
|
from utils.literal import Literal
|
|
from utils.constants import MAX_VALUE
|
|
from utils.memory_manager import MemoryManager
|
|
from utils.memory_range import mrange
|
|
|
|
# Impl of MemoryArray says we cant add our own Datatypes beside Literal and List
|
|
# BUUUUT we can just wrap our Datatype in a List :-)
|
|
# We store them in a MemoryArray internaly tho anyhow so we increment our Counters for the RAM
|
|
class HeapEntry:
|
|
def __init__(self, item, priority=1):
|
|
self.data = MemoryArray(Literal(2))
|
|
# 0: Content, 1: Prio
|
|
self.data[Literal(0)] = Literal(item)
|
|
self.data[Literal(1)] = Literal(priority)
|
|
|
|
def getItem(self):
|
|
return self.data[Literal(0)]
|
|
|
|
def getPriority(self):
|
|
return self.data[Literal(1)]
|
|
|
|
def setPriority(self, priority):
|
|
self.data[Literal(1)] = Literal(priority)
|
|
|
|
def __lt__(self, other):
|
|
if other is None:
|
|
return True
|
|
if isinstance(other, (int, float)):
|
|
return self.getPriority().value > other
|
|
return self.getPriority() > other.getPriority()
|
|
|
|
def __gt__(self, other):
|
|
if other is None:
|
|
return False
|
|
if isinstance(other, (int, float)):
|
|
return self.getPriority().value < other
|
|
return self.getPriority() < other.getPriority()
|
|
|
|
def __eq__(self, other):
|
|
return self.getPriority() == other.getPriority()
|
|
|
|
def __str__(self):
|
|
return f"({self.getItem()}, prio={self.getPriority()})"
|
|
|
|
class PriorityQueue:
|
|
def __init__(self, max_size : Literal = Literal(100)):
|
|
self.heap = MemoryArray(max_size)
|
|
# Add uninitialized HeapEntry Values so the Adds/Compares do not fail on emtpy stack.
|
|
# Would have to switch to MIN_VALUE if we switch what is a "Higher" Prio
|
|
for i in mrange(max_size.value):
|
|
self.heap[i].set([HeapEntry(MAX_VALUE, MAX_VALUE)])
|
|
self.size = MemoryCell(0)
|
|
|
|
def parent(self, i: Literal) -> Literal:
|
|
return MemoryCell(i.pred()) // Literal(2)
|
|
|
|
def leftChild(self, i: Literal) -> Literal:
|
|
return MemoryCell(MemoryCell(2) * i) + Literal(1)
|
|
|
|
def rightChild(self, i: Literal) -> Literal:
|
|
return MemoryCell(MemoryCell(2) * i) + Literal(2)
|
|
|
|
# Swap the Lists -> Therefore get the value which is the List and then Set it again
|
|
def swap(self, i: Literal, j: Literal):
|
|
tmp_i = self.heap[i].value
|
|
tmp_j = self.heap[j].value
|
|
self.heap[i].set(tmp_j)
|
|
self.heap[j].set(tmp_i)
|
|
|
|
def maxHeapify(self, i: Literal):
|
|
left = self.leftChild(i)
|
|
right = self.rightChild(i)
|
|
largest = i
|
|
|
|
if left < Literal(self.size.value) and self.heap[left].value[0] > self.heap[largest].value[0]:
|
|
largest = left
|
|
|
|
if right < Literal(self.size.value) and self.heap[right].value[0] > self.heap[largest].value[0]:
|
|
largest = right
|
|
|
|
if largest != i:
|
|
self.swap(i, largest)
|
|
self.maxHeapify(largest)
|
|
|
|
def insert(self, entry : HeapEntry):
|
|
if self.size >= self.heap.length():
|
|
raise IndexError("Heap full")
|
|
|
|
i = self.size
|
|
self.heap[i].set([entry])
|
|
|
|
while i > Literal(0) and self.heap[self.parent(i)].value[0] < self.heap[i].value[0]:
|
|
self.swap(i, self.parent(i))
|
|
i = self.parent(i)
|
|
|
|
self.size += Literal(1)
|
|
|
|
def pop(self):
|
|
if self.isEmpty():
|
|
raise IndexError("Queue is empty!")
|
|
|
|
max_item = self.heap[Literal(0)].value[0]
|
|
|
|
self.heap[Literal(0)] = self.heap[self.size - Literal(1)]
|
|
self.size -= Literal(1)
|
|
|
|
self.maxHeapify(Literal(0))
|
|
|
|
return max_item
|
|
|
|
def peek(self):
|
|
if self.isEmpty():
|
|
raise IndexError("Queue is empty")
|
|
return self.heap[Literal(0)].value[0]
|
|
|
|
def isEmpty(self):
|
|
return self.size == Literal(0)
|
|
|
|
def __len__(self):
|
|
return self.size
|
|
|
|
def __str__(self):
|
|
entries = []
|
|
for i in mrange(self.size.value):
|
|
entry = self.heap[i].value[0]
|
|
if entry.getItem() != MAX_VALUE:
|
|
entries.append(str(entry))
|
|
return "[" + ", ".join(entries) + "]"
|
|
|
|
# Insert here so we dont run into import problems, but can deliver this file Standalone
|
|
class BinaryTreeNode(MemoryCell):
|
|
def __init__(self, value):
|
|
super().__init__(value)
|
|
self.left = None
|
|
self.right = None
|
|
|
|
def __repr__(self):
|
|
return f"BinaryTreeNode(value={self.value}, left={self.left}, right={self.right})"
|
|
|
|
def __str__(self):
|
|
return str(self.value)
|
|
|
|
class BinaryTree:
|
|
def __init__(self):
|
|
self.root: BinaryTreeNode | None = None
|
|
|
|
def insert(self, value: BinaryTreeNode):
|
|
# Insert at Leaf, if smaller then left one, otherwise right one
|
|
def _insert(node: BinaryTreeNode | None, value) -> BinaryTreeNode:
|
|
if node is None:
|
|
return BinaryTreeNode(value)
|
|
if value < node:
|
|
node.left = _insert(node.left, value) # type: ignore -> Ignoring pywright errors
|
|
else:
|
|
node.right = _insert(node.right, value) # type: ignore -> Ignoring pywright errors
|
|
return node
|
|
|
|
self.root = _insert(self.root, value)
|
|
|
|
def traverse(self, mode="in", visual=False):
|
|
mode = mode.lower()
|
|
# Have internal depth counting
|
|
def InternalTraverse(node, prefix="", is_left=True, depth=0):
|
|
if node is None:
|
|
return [] if not visual else []
|
|
|
|
result = []
|
|
node_str = str(node)
|
|
|
|
prefixAcc = prefix + ("| " if is_left and depth > 0 else " ")
|
|
|
|
if visual:
|
|
connector = "+-- " if is_left else "L-- "
|
|
line = prefix + connector + node_str if depth > 0 else node_str
|
|
result.append(line)
|
|
else:
|
|
result.append(node_str)
|
|
|
|
if mode == "pre":
|
|
result += InternalTraverse(node.left, prefixAcc, True, depth + 1)
|
|
result += InternalTraverse(node.right, prefixAcc, False, depth + 1)
|
|
elif mode == "in":
|
|
result += InternalTraverse(node.left, prefixAcc, True, depth + 1)
|
|
result += InternalTraverse(node.right, prefixAcc, False, depth + 1)
|
|
elif mode == "post":
|
|
result += InternalTraverse(node.left, prefixAcc, True, depth + 1)
|
|
result += InternalTraverse(node.right, prefixAcc, False, depth + 1)
|
|
|
|
return result
|
|
|
|
if self.root is None:
|
|
return "(empty tree)" if visual else []
|
|
|
|
result = InternalTraverse(self.root)
|
|
return "\n".join(result) if visual else result
|
|
|
|
|
|
def levelOrderWithPriorityQueue(self):
|
|
if not self.root:
|
|
return []
|
|
|
|
# Create a priority queue, using a reduced prio for every new entry -> behaviour as regular queue FIFO
|
|
pq = PriorityQueue(Literal(1000))
|
|
|
|
# Again we cannot create a MemoryArray of dynamic sizes and also cannot create a string as MemoryCell does not like it
|
|
# Again we just create a list holding a single dummy Entry (to set its size to 1) and then just use this "list" as our string
|
|
# Appending to it is easy as it is just a regular list and in the end we return it
|
|
# Like MemoryCell("").value.append("STRING") will fail. But list-wrap works.
|
|
#
|
|
# Sorry for Syntax, dont know any better way to have everything as RAM-Managed memory:-(
|
|
result = MemoryArray(["MYSTRING"])
|
|
result[Literal(0)].set([]);
|
|
|
|
counter = MemoryCell(0)
|
|
def nextPriority():
|
|
val = counter.value
|
|
counter.set(Literal(val + 1))
|
|
return val
|
|
pq.insert(HeapEntry([self.root], nextPriority()))
|
|
|
|
while not pq.isEmpty():
|
|
entry = pq.pop()
|
|
node = entry.getItem().value
|
|
|
|
result[Literal(0)].value.append(str(node[0]))
|
|
|
|
if node[0].left:
|
|
pq.insert(HeapEntry([node[0].left], nextPriority()))
|
|
if node[0].right:
|
|
pq.insert(HeapEntry([node[0].right], nextPriority()))
|
|
|
|
return result[Literal(0)]
|
|
|
|
|
|
def __str__(self):
|
|
return str(self.traverse(mode="PrE", visual=True))
|
|
|
|
def analyze_complexity(fn, sizes):
|
|
"""
|
|
Analysiert die Komplexität einer maximalen Teilfolgenfunktion.
|
|
|
|
:param max_sequence_func: Die Funktion, die analysiert wird.
|
|
:param sizes: Eine Liste von Eingabegrößen für die Analyse.
|
|
"""
|
|
for size in sizes:
|
|
MemoryManager.purge() # Speicher zurücksetzen
|
|
random_array = MemoryArray.create_random_array(size, -100, 100)
|
|
fn(random_array, Literal(0), random_array.length().pred())
|
|
MemoryManager.save_stats(size)
|
|
|
|
MemoryManager.plot_stats(["cells", "adds", "compares", "reads", "writes"])
|
|
|
|
|
|
if __name__ == '__main__':
|
|
# For debug, assert if working and complexity-analysis
|
|
# example()
|
|
|
|
print("Sorry for the Syntax and the large file, tried to keep everything as a standalone file to help make it \" download and run \".\n \
|
|
Also did - once again - not find a better way to have a queue managed by the RAM contain the values of non-integer-attributes I \n\
|
|
needed it to. Therefore i reused my Priorityqueue and its accesses via the unspecified wrapped list.");
|
|
|
|
# for filename in ["data/seq0.txt", "data/seq1.txt", "data/seq2.txt" ,"data/seq3.txt"]:
|
|
for filename in [ "data/seq0.txt"]:
|
|
print(filename)
|
|
binTreeData = MemoryArray.create_array_from_file(filename)
|
|
binTree = BinaryTree()
|
|
for value in binTreeData:
|
|
binTree.insert(BinaryTreeNode(value))
|
|
|
|
# Print overlaoded InOrder traversal
|
|
print(binTree)
|
|
# print(binTree.traverse(mode="pre", visual=False))
|
|
# print(binTree.traverse(mode="in", visual=False))
|
|
# print(binTree.traverse(mode="post", visual=False))
|
|
# Print Levelorder traversal:
|
|
print(binTree.levelOrderWithPriorityQueue())
|