forked from hofmannol/AlgoDatSoSe25
151 lines
4.5 KiB
Python
151 lines
4.5 KiB
Python
from utils.memory_array import MemoryArray
|
|
from utils.memory_cell import MemoryCell
|
|
from utils.memory_manager import MemoryManager
|
|
from utils.literal import Literal
|
|
import random
|
|
|
|
class PriorityQueue:
|
|
|
|
def __init__(self, size: Literal):
|
|
self.items = MemoryArray(size)
|
|
self.heapsize = MemoryCell(0)
|
|
|
|
def __len__(self):
|
|
return self.heapsize.value
|
|
|
|
def insert(self, item: MemoryCell):
|
|
if self.heapsize == self.items.length():
|
|
raise Exception("Queue is full")
|
|
self.heapsize.set(self.heapsize.succ())
|
|
self.items[adjust_index(self.heapsize)].set(item.value)
|
|
heapyfy_up(self.items, self.heapsize)
|
|
|
|
|
|
def pop(self) -> MemoryCell | None:
|
|
if self.is_empty():
|
|
return None
|
|
result = MemoryCell(self.items[Literal(0)])
|
|
self.heapsize.set(self.heapsize.pred())
|
|
if self.heapsize > Literal(1):
|
|
swap(self.items, 0, int(self.heapsize))
|
|
max_heapyfy(self.items, Literal(1), self.heapsize)
|
|
return result
|
|
|
|
def peek(self) -> MemoryCell | None:
|
|
if self.is_empty():
|
|
return None
|
|
return MemoryCell(self.items[Literal(0)])
|
|
|
|
def is_empty(self) -> bool:
|
|
return self.heapsize == Literal(0)
|
|
|
|
def __str__(self):
|
|
result = "[ "
|
|
for i, cell in enumerate(self.items.cells):
|
|
if i == int(self.heapsize):
|
|
result += "| "
|
|
result += str(cell) + " "
|
|
result += "]"
|
|
return result
|
|
|
|
def left_child(i: Literal):
|
|
return Literal(2 * int(i))
|
|
|
|
|
|
def right_child(i: Literal):
|
|
return Literal(2 * int(i) + 1)
|
|
|
|
|
|
def adjust_index(i: Literal):
|
|
return i.pred()
|
|
|
|
def heapyfy_up(z: MemoryArray, i: Literal):
|
|
if i == Literal(1):
|
|
return
|
|
parent = Literal(int(i) // 2)
|
|
if z[adjust_index(parent)] >= z[adjust_index(i)]:
|
|
return
|
|
swap(z, int(i)-1, int(parent)-1)
|
|
heapyfy_up(z, parent)
|
|
|
|
|
|
def max_heapyfy(z: MemoryArray, i: Literal, heapsize: Literal):
|
|
l = left_child(i)
|
|
r = right_child(i)
|
|
with MemoryCell(i) as max_value:
|
|
if l <= heapsize and z[adjust_index(l)] > z[adjust_index(i)]:
|
|
max_value.set(l)
|
|
if r <= heapsize and z[adjust_index(r)] > z[adjust_index(max_value)]:
|
|
max_value.set(r)
|
|
if max_value != i:
|
|
swap(z, int(i)-1, int(max_value)-1)
|
|
max_heapyfy(z, max_value, heapsize)
|
|
|
|
|
|
def swap(z: MemoryArray, i: int, j: int):
|
|
tmp = z[Literal(i)].value
|
|
z[Literal(i)] = z[Literal(j)]
|
|
z[Literal(j)].set(tmp)
|
|
|
|
|
|
def analyze_complexity_insert(sizes, presorted=False):
|
|
"""
|
|
Analysiert die Komplexität der Insert-Funktion.
|
|
"""
|
|
for size in sizes:
|
|
MemoryManager().purge() # Speicher zurücksetzen
|
|
pq = PriorityQueue(Literal(size))
|
|
insert_list = [random.randint(-100, 100) for _ in range(size)]
|
|
if presorted:
|
|
insert_list.sort()
|
|
for insert_value in insert_list[:-1]:
|
|
pq.insert(MemoryCell(insert_value))
|
|
MemoryManager().reset()
|
|
pq.insert(MemoryCell(insert_list[-1]))
|
|
MemoryManager.save_stats(size)
|
|
|
|
MemoryManager.plot_stats(["cells", "compares", "writes"])
|
|
|
|
|
|
def analyze_complexity_pop(sizes, presorted=False):
|
|
"""
|
|
Analysiert die Komplexität der Pop-Funktion.
|
|
"""
|
|
for size in sizes:
|
|
MemoryManager().purge() # Speicher zurücksetzen
|
|
pq = PriorityQueue(Literal(size))
|
|
insert_list = [random.randint(-100, 100) for _ in range(size)]
|
|
if presorted:
|
|
insert_list.sort()
|
|
for insert_value in insert_list:
|
|
pq.insert(MemoryCell(insert_value))
|
|
MemoryManager().reset()
|
|
pq.pop()
|
|
MemoryManager.save_stats(size)
|
|
|
|
MemoryManager.plot_stats(["cells", "compares", "writes"])
|
|
|
|
|
|
if __name__ == '__main__':
|
|
length = Literal(10)
|
|
pq = PriorityQueue(length)
|
|
for i in range(10):
|
|
space_left = int(length) - len(pq)
|
|
if space_left > 0:
|
|
insert_count = random.randint(1, space_left)
|
|
insert_sequence = [random.randint(1, int(length)) for _ in range(insert_count)]
|
|
print(f"-> {insert_sequence}")
|
|
for j in insert_sequence:
|
|
pq.insert(MemoryCell(j))
|
|
print(f"{pq}")
|
|
if not pq.is_empty():
|
|
pop_count = random.randint(1, len(pq))
|
|
output_sequence = [int(pq.pop()) for _ in range(pop_count)]
|
|
print(f"<- {output_sequence}")
|
|
print(f"{pq}")
|
|
|
|
sizes = range(10, 501, 5)
|
|
analyze_complexity_insert(sizes, presorted=True)
|
|
analyze_complexity_pop(sizes, presorted=True)
|
|
|