Slave ragazzi! Ho un problema con il codice nel 'main'. Funziona perfettamente ma vorrei modificarlo per fare una cosa in particolare.

nel main istanzio un albero e lo chiamo 'T'. Poi creo una radice con elemento la stringa "Auto" tramite la riga: ' radice = T._add_root("Auto") '.

Dopo, creata la lista ' lista ', creo il nodo figlio della radice che contiene la lista 'lista', la quale ha 3 elementi (In pratica è un albero generico che può avere più figli, usando come contenitore di tali figli una struttura dati, in questo caso un lista).

Il mio obiettivo è creare un nuovo nodo (lista_opel, lista_citroen, lista_suzuki) che contenga una lista di elmenti, per ogni elemento della lista ' lista '

(in pratica questi nuovi nodi saranno i "nipoti" della radice).




Il problema è che la lista 'lista_opel', e allo stesso modo le altre, diventa un nodo figlio dell'intero lista ' lista ' e non un nodo figlio di uno solo degli elementi della lista 'lista'.




Vorrei creare qualcosa del genere:

ecco l'immagine (scusate se non sono riuscito a inserirla ma era in locale e non su internet)







https://drive.google.com/open?id=1qn1ZRBWmOaYEHzmktafmpRQGLJo6WJya







come vedete dall'immagine il primo nodo ha un genitore "parent", un elemento "element" (New York) e 4 figli "children". I figli sono contenuti all'interno di una struttura dati e ogni elemento della struttura dati ha un nodo figlio con uguali caratteristiche.

Ora, al posto di un nodo con un solo elemento, come quelli che contengono "Baltimore", "Chicago", "Providence", "Seattle", vorrei dei nodi che contengono delle liste.

credo che il procedimento sia lo stesso ma non so davvero come realizzarlo.

Ringrazio chiunque riesca ad aiutarmi lo apprezzerei davvero tanto.









albero.



albero_binario import Albero Binario

class Albero Binario Concatenato(Albero Binario):

class _Node:

__slots__ = '_element', '_parent', '_child'

def __init__(self, element, parent = None, child = None):

self._element = element
self._parent = parent
self._child = child

class Position(Albero Binario.Position):

def __init__(self, container, node):

self._container = container
self._node = node

def element(self):

return self._node._element

def __eq__(self, other):

return type(other) is type(self) and other._node is self._node


def _validate(self, p):

if not isinstance(p, self.Position):
raise TypeError('p deve essere di tipo position')

if p._container is not self:
raise ValueError('p non appartiene a questo contenitore')

if p._node._parent is p._node:
raise ValueError('p non è più valido')
return p._node

def _make_position(self, node):

return self.Position(self, node) if node is not None else None

def __init__(self):

self._root = None
self._size = 0

def __len__(self):

return self._size

def root(self):

return self._make_position(self._root)

def parent(self, p):

node = self._validate(p)
return self._make_position(node._parent)

def child(self, p):

node = self._validate(p)
return self._make_position(node._child)



def num_children(self, p):

node = self._validate(p)
count = 0
if node._left is not None:
count += 1
if node._right is not None:
count += 1
return count


def _add_root(self, e):

if self._root is not None: raise ValueError('la radice esiste')
self._size = 1
self._root = self._Node(e)
return self._make_position(self._root)



def _add_child(self, p, e):

node = self._validate(p)
if node._child is not None: raise ValueError('ha già dei figli. I\n'
'figli devono essere '
'contenuti in una '
'struttura dati.')
self._size += 1
node._child = self._Node(e, node)
return self._make_position(node._child)



def replace(self, p, e):

node = self._validate(p)
old = node._element
node._element = e
return old

def _delete(self, p):

node = self._validate(p)
if self.num_children(p) == 2: raise ValueError('p ha 2 figli')
child = node._left if node._left else node._right
if child is not None:
child._parent = node._parent
if node is self._root:
self._root = child
else:
parent = node._parent
if node is parent._left:
parent._left = child
else:
parent._right = child
self._size -= 1
node._parent = node
return node._element


def _attach(self, p, t1, t2):

node = self._validate(p)
if not self.is_leaf(p): raise ValueError('la posizione deve essere una foglia')
if not type(self) is type(t1) is type(t2):
raise TypeError('gli alberi devono essere dello stesso tipo')
self._size += len(t1) + len(t2)
if not t1.is_empty():
t1._root._parent = node
node._left = t1._root
t1._root = None
t1._size = 0
if not t2.is_empty():
t2._root._parent = node
node._right = t2._root
t2._root = None
t2._size = 0


if __name__ == '__main__':



print("\nALBERO GENERICO\n\n")
T = Albero Binario Concatenato()
if T.is_empty():
print("\nl'albero è vuoto\n")

radice = T._add_root("Auto")
print("l'elemento della radice è: ", radice.element())

lista = ["Opel", "Citroen", "Suzuki"]

marche = T._add_child(radice, lista)

print("figlio Auto: ", marche.element())

lista_opel = ["Astra", "Corsa", "Zafira", "Crossland X", "Agila"]
lista_Citroen = ["C3", "C4", "C1", "Berlingo", "Cactus", "C-Zero"]
lista_Suzuki = ["Jimny", "Swift", "Ignis", "Vitara", "Celerio", "Baleno"]


figli_opel = T._add_child(marche, lista_opel)

print("figlio di opel: ", figli_opel.element())