Web M&M
https://mam.matfyz.cz
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
147 lines
4.2 KiB
147 lines
4.2 KiB
from django.core.exceptions import ObjectDoesNotExist
|
|
# NOTE: node.prev a node.succ jsou implementovány přímo v models.TreeNode
|
|
# TODO: Všechny tyto funkce se naivně spoléhají na to, že jako parametr dostanou nějaký TreeNode (některé možná zvládnou i None)
|
|
|
|
# Slouží k debugování pro rychlé získání představy o podobě podstromu pod tímto TreeNode.
|
|
def print_tree(node,indent=0):
|
|
# FIXME: Tady se spoléháme na to, že nedeklarovaný primární klíč se jmenuje by default 'id', což není úplně správně
|
|
print("{}{} (id: {})".format(" "*indent,node, node.id))
|
|
if node.first_child:
|
|
print_tree(node.first_child, indent=indent+2)
|
|
if node.succ:
|
|
print_tree(node.succ, indent=indent)
|
|
|
|
# Django je trošku hloupé, takže node.prev nevrací None, ale hází django.core.exceptions.ObjectDoesNotExist
|
|
def safe_pred(node):
|
|
try:
|
|
return node.prev
|
|
except ObjectDoesNotExist:
|
|
return None
|
|
|
|
def first_brother(node):
|
|
brother = node
|
|
while safe_pred(brother) is not None:
|
|
brother = safe_pred(brother)
|
|
return brother
|
|
|
|
# A to samé pro .father_of_first
|
|
def safe_father_of_first(node):
|
|
first = first_brother(node)
|
|
try:
|
|
return first.father_of_first
|
|
except ObjectDoesNotExist:
|
|
return None
|
|
|
|
## Rodinné vztahy
|
|
def get_parent(node):
|
|
# Nejdřív získáme prvního potomka...
|
|
while safe_pred(node) is not None:
|
|
node = safe_pred(node)
|
|
# ... a z prvního potomka umíme najít rodiče
|
|
return safe_father_of_first(node)
|
|
|
|
# Obecný next: další Node v "the-right-order" pořadí (já, pak potomci, pak sousedé)
|
|
def general_next(node):
|
|
# Máme potomka?
|
|
if node.first_child is not None:
|
|
return node.first_child
|
|
# Nemáme potomka.
|
|
# Chceme najít následníka sebe, nebo některého (toho nejblíž příbuzného) z našich předků (tatínka, dědečka, ...)
|
|
while node.succ is None:
|
|
node = get_parent(node)
|
|
if node is None:
|
|
return None # žádný z předků nemá následníka, takže žádny vrchol nenásleduje.
|
|
return node.succ
|
|
|
|
def last_brother(node):
|
|
while node.succ is not None:
|
|
node = node.succ
|
|
return node
|
|
|
|
def general_prev(node):
|
|
# Předchůdce je buď rekurzivně poslední potomek předchůdce, nebo náš otec.
|
|
# Otce vyřešíme nejdřív:
|
|
if safe_pred(node) is None:
|
|
return safe_father_of_first(node)
|
|
pred = safe_pred(node)
|
|
while pred.first_child is not None:
|
|
pred = last_brother(pred.first_child)
|
|
# pred nyní nemá žádné potomky, takže je to poslední rekurzivní potomek původního předchůdce
|
|
return pred
|
|
|
|
# Generátor pravých bratrů (konkrétně sebe a následujících potomků)
|
|
# Generátor potomků níže spoléhá na to, že se tohle dá volat i s parametrem None.
|
|
def me_and_right_brothers(node):
|
|
current = node
|
|
while current is not None:
|
|
yield current
|
|
current = current.succ
|
|
|
|
# Generátor všech sourozenců (vč. sám sebe)
|
|
def all_brothers(node):
|
|
# Najdeme prvního bratra
|
|
fb = first_brother(node)
|
|
marb = me_and_all_brothers(fb)
|
|
for cur in marb:
|
|
yield cur
|
|
|
|
def all_proper_brothers(node):
|
|
all = all_brothers(node)
|
|
for br in all:
|
|
if br is node:
|
|
continue
|
|
yield br
|
|
|
|
# Generátor potomků
|
|
def all_children(node):
|
|
brothers = all_brothers(node.first_child)
|
|
for br in brothers:
|
|
yield br
|
|
|
|
# Generátor následníků v "the-right-order"
|
|
|
|
## Filtrační hledání
|
|
# Najdi dalšího bratra nějakého typu, nebo None.
|
|
# hledá i podtřídy, i.e. get_next_brother_of_type(neco, TreeNode) je prostě succ.
|
|
def get_next_brother_of_type(current, type):
|
|
pass
|
|
def get_prev_brother_of_type(current, type):
|
|
pass
|
|
|
|
# Totéž pro "the-right-order" pořadí
|
|
def get_next_node_of_type(current, type):
|
|
pass
|
|
def get_next_node_of_type(current, type):
|
|
pass
|
|
|
|
|
|
|
|
|
|
# Editace stromu:
|
|
def create_node_after(predecessor, type, **kwargs):
|
|
pass
|
|
|
|
# Vyrábí prvního syna, ostatní nalepí za (existují-li)
|
|
def create_child(parent, type, **kwargs):
|
|
pass
|
|
|
|
def create_node_before(some, arguments, but, i, dont, know, which, yet):
|
|
pass
|
|
# Tohle bude hell.
|
|
|
|
# ValueError, pokud je (aspoň) jeden parametr None
|
|
def swap(node, other):
|
|
pass
|
|
|
|
def swap_pred(node):
|
|
pass
|
|
def swap_succ(node):
|
|
pass
|
|
|
|
# Rotace stromu
|
|
# Dokumentace viz wiki:
|
|
# (lower bude jednoduchá rotace, ne mega, existence jednoduché rotace mi došla až po nakreslení obrázku)
|
|
def raise_node(node):
|
|
pass
|
|
def lower_node(node):
|
|
pass
|
|
|