•
•
𝑇 𝑁
• 𝑇 𝑟∈𝑁 𝑟 𝑟 𝑇
• 𝑛∈𝑁 𝑣∈𝑁 𝑣
𝑣
𝑣 𝑣
𝑣 𝑣
𝑢 𝑣 𝑢=𝑣 𝑢 𝑣
𝑣 𝑢 𝑢 𝑣
𝑇 𝑣 𝑣 𝑇
𝑣
𝑇 𝑢, 𝑣 𝑢 𝑣
𝑛
𝑛−1
𝛼 𝛽 𝛾
𝑒 𝑓 𝑔
api/ controllers/
api/ models/
api/ routes/
api/ __init__.py
api/ database.py
controllers/ channel_controller.py
models/ channel.py
routes/ channel_routes.py
𝑇 𝑝0 , 𝑝1 , . . . , 𝑝𝑛 (𝑝𝑖 , 𝑝𝑖+1 ) 𝑇
𝑖 0 𝑛−1
𝑇
api/ models/ channel.py
api/ controllers/ channel_controller.py
api/ routes/ channel_routes.py
api/ __init__.py
api/ database.py
𝑇
𝑒 api/ controllers/ 𝑗 controllers/ channel_controller.py
𝑒 api/ controllers/
𝑗 controllers/ channel_controller.py
𝑒 controllers/
N
self._element
self._parent
self._children
N.element()
N.add(element, parent)
Node
class Node:
def __init__(self, element, parent=None, children=None):
self._element = element
self._parent = parent
if children is None:
self._children = []
else:
self._children = children
def element(self):
return self._element
def add(self, element):
temp = Node(element)
if temp not in self._children:
temp._parent = self
self._children.append(temp)
return temp
else:
raise ValueError("El nodo ya tiene un padre.")
def __eq__(self, other):
return type(other) is type(self) and other._element is
self._element
def __ne__(self, other):
return not (self == other)
def __str__(self):
return f"* {self.element()}"
def __repr__(self):
return f"* {self.element()}"
ADTTree
T.root() T None T
T.is_root(p) True p T
T.parent(p) p None p
T.num_children(p) p
T.children(p) p
T.is_leaf(p) True p
len(T) T
T.is_empty() True T
T.nodes() T
Node
iter(T) T
T Node
from node import Node
class ADTTree:
def __init__(self, root=None):
self._size = 0
if root is not None:
self.add_root(root)
else:
self._root = None
def add_root(self, element):
if not self.is_empty():
raise ValueError("El árbol ya tiene una raíz.")
self._root = Node(element)
self._size += 1
def __len__(self):
return self._size
def root(self):
return self._root
def is_root(self, p):
return p == self.root()
def parent(self, p):
return p._parent
def is_empty(self):
if self.root() is None:
return True
else:
return False
def num_children(self, p):
return len(p._children)
def children(self, p):
for child in p._children:
yield child
def is_leaf(self, p):
if self.num_children(p) > 0:
return False
else:
return True
def nodes(self):
pass
def __iter__(self):
pass
def __str__(self):
return self._str_recursive(self._root)
def _str_recursive(self, node, depth=0):
result = " " * depth + str(node) + "\n"
for child in node._children:
result += self._str_recursive(child, depth + 1)
return result
nodes iter
ADTTree
𝒑
𝑻
𝒑 𝒑
• 𝒑 𝒑
• 𝒑 𝒑
𝑨𝑫𝑻𝑻𝒓𝒆𝒆 𝒑 𝑻
def depth(self, p):
"""Calcula la profundidad de un nodo p para un árbol T"""
if self.is_root(p):
return 0
else:
return 1 + self.depth(self.parent(p))
𝒑 𝒑
𝒑 𝒑
𝑨𝑫𝑻𝑻𝒓𝒆𝒆 𝒑 𝑻
def height(self, p):
"""Calcula la altura de un nodo p para un árbol T"""
if self.is_leaf(p):
return 0
else:
heights = []
for child in self.children(p):
heights.append(self.height1(child))
return 1 + max(heights) # 1 + máxima altura de los hijos de p
𝒑 𝑻 height
_recursive_height
def height(self, p=None):
"""Calcula la altura de un nodo p para un árbol T"""
if p is None:
p = self.root()
return self._recursive_height(p)
height
height
