forked from hofmannol/AlgoDatSoSe25
112 lines
3.5 KiB
Python
112 lines
3.5 KiB
Python
import logging
|
|
logger = logging.getLogger(__name__)
|
|
logging.basicConfig(level=logging.DEBUG)
|
|
|
|
from utils.memory_array import MemoryArray
|
|
from utils.memory_cell import MemoryCell
|
|
from utils.literal import Literal
|
|
from utils.constants import MIN_VALUE
|
|
from utils.memory_manager import MemoryManager
|
|
from utils.memory_range import mrange
|
|
|
|
def example():
|
|
initial = [6, 5, 3, 8, 1, 7, 2, 4]
|
|
# initial = [-6, -5, -3, -8, 1, 7, 2, 4]
|
|
toSort = MemoryArray(initial)
|
|
# init_from_size not accessible?
|
|
quickSort(toSort, Literal(0), mode=0)
|
|
logger.debug(f"sorted {toSort} vs initial {initial}")
|
|
assert all(toSort[Literal(i)] == Literal(i+1) for i in range(len(initial))), "Array not sorted correctly"
|
|
|
|
# analyze_complexity(quickSort, [10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
|
|
|
|
def getPivot(z: MemoryArray, l: Literal, r: Literal, mode) -> Literal:
|
|
if mode == 0:
|
|
return r
|
|
else:
|
|
mid = MemoryCell(l) + MemoryCell(MemoryCell(r) - l) // Literal(2)
|
|
|
|
# Return median of left, middle, and right elements
|
|
if ((z[l] <= z[mid] and z[mid] <= z[r]) or
|
|
(z[r] <= z[mid] and z[mid] <= z[l])):
|
|
return mid
|
|
elif ((z[mid] <= z[l] and z[l] <= z[r]) or
|
|
(z[r] <= z[l] and z[l] <= z[mid])):
|
|
return l
|
|
else:
|
|
return r
|
|
|
|
|
|
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 quickSort(z: MemoryArray, l: Literal = Literal(0), r: Literal = Literal(-1), mode=0):
|
|
if r == Literal(-1):
|
|
r = z.length().pred();
|
|
if l < r:
|
|
q = partition(z, l, r, mode)
|
|
quickSort(z, l, q.pred())
|
|
quickSort(z, q.succ(), r)
|
|
|
|
def partition(z: MemoryArray, l: Literal, r: Literal, mode):
|
|
# Get pivot
|
|
pivot_idx = getPivot(z, l, r, mode)
|
|
|
|
# If pivot is not already at the right end, swap it there
|
|
if pivot_idx != r:
|
|
swap(z, int(pivot_idx), int(r))
|
|
|
|
# with MemoryCell(z[r]) as pivot, MemoryCell(l) as i, MemoryCell(r.pred()) as j:
|
|
pivot = MemoryCell(z[r])
|
|
i = MemoryCell(l)
|
|
j = MemoryCell(r.pred())
|
|
|
|
while i < j:
|
|
while z[i] < pivot:
|
|
i.set(i.succ())
|
|
while j > l and z[j] >= pivot:
|
|
j.set(j.pred())
|
|
if i < j:
|
|
swap(z, int(i), int(j))
|
|
i.set(i.succ())
|
|
j.set(j.pred())
|
|
if i == j and z[i] < pivot:
|
|
i.set(i.succ())
|
|
if z[i] != pivot:
|
|
swap(z, int(i), int(r))
|
|
return Literal(i)
|
|
|
|
|
|
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)
|
|
other_array = MemoryArray([-1] * size)
|
|
fn(random_array, other_array)
|
|
MemoryManager.save_stats(size)
|
|
|
|
MemoryManager.plot_stats(["cells", "adds", "compares"])
|
|
|
|
|
|
if __name__ == '__main__':
|
|
# For debug, assert if working and complexity-analysis
|
|
example()
|
|
|
|
toSort = MemoryArray.create_array_from_file("data/seq0.txt")
|
|
print(toSort)
|
|
quickSort(toSort)
|
|
print(toSort)
|
|
|
|
for filename in ["data/seq0.txt", "data/seq1.txt", "data/seq2.txt", "data/seq3.txt"]:
|
|
print(filename)
|
|
toSort = MemoryArray.create_array_from_file(filename)
|
|
quickSort(toSort,Literal(0), Literal(-1), mode=0)
|