forked from hofmannol/AlgoDatSoSe25
121 lines
3.8 KiB
Python
121 lines
3.8 KiB
Python
from utils.literal import Literal
|
|
from utils.memory_cell import MemoryCell
|
|
from utils.memory_array import MemoryArray
|
|
from b_tree_node import BTreeNode
|
|
|
|
class BTree:
|
|
def __init__(self, m: int):
|
|
self.m = m
|
|
self.root = BTreeNode(m)
|
|
|
|
def search(self, value, start: BTreeNode = None) -> BTreeNode | None:
|
|
if not start:
|
|
start = self.root
|
|
start.load()
|
|
i = 0
|
|
if not isinstance(value, MemoryCell):
|
|
value = MemoryCell(value)
|
|
while i < start.n and value > start.value[Literal(i)]:
|
|
i += 1
|
|
if i < start.n and value == start.value[Literal(i)]:
|
|
return start
|
|
if start.leaf:
|
|
return None
|
|
return self.search(value, start.children[i])
|
|
|
|
def split_child(self, parent: BTreeNode, i: int):
|
|
child = parent.children[i]
|
|
child.load()
|
|
h = BTreeNode(self.m)
|
|
h.leaf = child.leaf
|
|
h.n = self.m - 1
|
|
for j in range(self.m - 1):
|
|
h.value[Literal(j)] = child.value[Literal(j + self.m)]
|
|
if not h.leaf:
|
|
for j in range(self.m):
|
|
h.children[j] = child.children[j + self.m]
|
|
for j in range(self.m, child.n + 1):
|
|
child.children[j] = None
|
|
child.n = self.m - 1
|
|
child.save()
|
|
h.save()
|
|
for j in range(parent.n, i, -1):
|
|
parent.children[j + 1] = parent.children[j]
|
|
parent.value[Literal(j)] = parent.value[Literal(j - 1)]
|
|
parent.children[i + 1] = h
|
|
parent.value[Literal(i)] = child.value[Literal(self.m - 1)]
|
|
parent.n += 1
|
|
parent.save()
|
|
|
|
def insert(self, value):
|
|
if not isinstance(value, MemoryCell):
|
|
value = MemoryCell(value)
|
|
r = self.root
|
|
if r.n == 2 * self.m - 1:
|
|
h = BTreeNode(self.m)
|
|
self.root = h
|
|
h.leaf = False
|
|
h.n = 0
|
|
h.children[0] = r
|
|
self.split_child(h, 0)
|
|
self.insert_in_node(h, value)
|
|
else:
|
|
self.insert_in_node(r, value)
|
|
|
|
def insert_in_node(self, start: BTreeNode, value):
|
|
start.load()
|
|
i = start.n
|
|
if start.leaf:
|
|
while i >= 1 and value < start.value[Literal(i-1)]:
|
|
start.value[Literal(i)] = start.value[Literal(i-1)]
|
|
i -= 1
|
|
start.value[Literal(i)].set(value)
|
|
start.n += 1
|
|
start.save()
|
|
else:
|
|
j = 0
|
|
while j < start.n and value > start.value[Literal(j)]:
|
|
j += 1
|
|
if start.children[j].n == 2 * self.m - 1:
|
|
self.split_child(start, j)
|
|
if value > start.value[Literal(j)]:
|
|
j += 1
|
|
self.insert_in_node(start.children[j], value)
|
|
|
|
def traversal(self, callback):
|
|
def traversal_recursive(node, callback):
|
|
i = 0
|
|
while i < node.n:
|
|
if not node.leaf:
|
|
traversal_recursive(node.children[i], callback)
|
|
callback(node.value[Literal(i)])
|
|
i += 1
|
|
if not node.leaf:
|
|
traversal_recursive(node.children[i], callback)
|
|
|
|
traversal_recursive(self.root, callback)
|
|
|
|
def walk(self):
|
|
def print_key(key):
|
|
print(key, end=" ")
|
|
|
|
self.traversal(print_key)
|
|
|
|
def height(self, start: BTreeNode = None):
|
|
if not start:
|
|
start = self.root
|
|
if start.leaf:
|
|
return 0
|
|
return 1 + self.height(start.children[0])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
a = MemoryArray.create_array_from_file("data/seq3.txt")
|
|
tree = BTree(3)
|
|
for cell in a:
|
|
tree.insert(cell)
|
|
print(f"Height: {tree.height()}")
|
|
tree.walk()
|
|
s = tree.search(0)
|
|
print(f"\nKnoten mit 0: {str(s)}")
|