class Grafo(object):
def __init__(self, dirigido=True):
self.dirigido = dirigido
self.inicio = Lista()
def insertar_vertice(self,
dato,
criterio='info',
data=None): # ! agregar otro
self.inicio.insertar(
{
'info': dato,
'visitado': False,
'aristas': Lista(),
'data': data
}, criterio)
def insertar_arista(self,
peso,
origen,
destino,
criterio='destino',
data=None): # ! agregar otro
ver_origen = self.inicio.busqueda(origen, 'info')
ver_destino = self.inicio.busqueda(destino, 'info')
if (ver_origen != -1 and ver_destino != -1):
self.inicio.obtener_elemento(ver_origen)['aristas'].insertar(
{
'peso': peso,
'destino': destino,
'data': data
}, criterio)
if (not self.dirigido and origen != destino):
data_aux = deepcopy(data)
if (data):
data_aux['relacion'].reverse()
self.inicio.obtener_elemento(ver_destino)['aristas'].insertar(
{
'peso': peso,
'destino': origen,
'data': data_aux
}, criterio)
else:
print('los vertices origen o destino no estan en el grafo....',
origen, destino)
def grafo_vacio(self):
return self.inicio.lista_vacia()
def tamanio(self):
return self.inicio.tamanio()
def buscar_vertice(self, clave, criterio='info'):
return self.inicio.busqueda(clave, criterio=criterio)
def buscar_arista(self, origen, destino, criterio='destino'):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
return self.inicio.obtener_elemento(
ver_origen)['aristas'].busqueda(destino, criterio)
else:
return ver_origen
def barrido_vertices(self):
self.inicio.barrido()
def es_adyacente(self, origen, destino):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
destino = self.buscar_arista(origen, destino)
if (destino != -1):
return True
else:
return False
else:
return False
def adyacentes(self, origen):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
self.inicio.obtener_elemento(ver_origen)['aristas'].barrido()
def eliminar_vertice(self, clave):
aux = self.inicio.eliminar(clave, criterio='info')
for posicion in range(self.tamanio()):
origen = self.inicio.obtener_elemento(posicion)['info']
self.eliminar_arista(origen, clave)
return aux
def eliminar_arista(self, origen, destino):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
self.inicio.obtener_elemento(ver_origen)['aristas'].eliminar(
destino, 'destino')
if (not self.dirigido):
ver_destino = self.inicio.busqueda(destino, 'info')
if (ver_destino != -1):
self.inicio.obtener_elemento(
ver_destino)['aristas'].eliminar(origen, 'destino')
def barrido_profundidad(self, ver_origen):
"""Barrido en profundidad del grafo."""
while (ver_origen < self.inicio.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
print(vertice['info'])
aristas = 0
while (aristas < vertice['aristas'].tamanio()):
arista = vertice['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(arista['destino'])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
if (not nuevo_vertice['visitado']):
self.barrido_profundidad(pos_vertice)
aristas += 1
ver_origen += 1
def barrido_amplitud(self, ver_origen):
"""Barrido en amplitud del grafo."""
cola = Cola()
while (ver_origen < self.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
cola.arribo(vertice)
while (not cola.cola_vacia()):
nodo = cola.atencion()
print(nodo['info'], nodo['data'])
aristas = 0
while (aristas < nodo['aristas'].tamanio()):
adyacente = nodo['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(adyacente['destino'])
nuevo_vertice = self.inicio.obtener_elemento(
pos_vertice)
if (not nuevo_vertice['visitado']):
nuevo_vertice['visitado'] = True
cola.arribo(nuevo_vertice)
aristas += 1
ver_origen += 1
def marcar_no_visitado(self):
"""Marca todos losvertices del grafo como no visitados."""
for i in range(self.tamanio()):
self.inicio.obtener_elemento(i)['visitado'] = False
def existe_paso(self, ver_origen, ver_destino):
"""Barrido en profundidad del grafo."""
resultado = False
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
aristas = 0
while (aristas < vertice['aristas'].tamanio() and not resultado):
arista = vertice['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(arista['destino'])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
destino = self.inicio.obtener_elemento(ver_destino)
if (nuevo_vertice['info'] == destino['info']):
return True
else:
resultado = self.existe_paso(pos_vertice, ver_destino)
aristas += 1
return resultado
def dijkstra(self, ver_origen, ver_destino):
"""Algoritmo de Dijkstra para hallar el camino mas corto."""
no_visitados = HeapMin()
camino = Pila()
aux = 0
while (aux < self.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
vertice_aux = self.inicio.obtener_elemento(aux)
vertice_aux['anterior'] = None
if (vertice_aux['info'] == vertice['info']):
no_visitados.arribo([vertice_aux['info'], None], 0)
else:
no_visitados.arribo([vertice_aux['info'], None], inf)
aux += 1
while (not no_visitados.vacio()):
dato = no_visitados.atencion()
camino.apilar(dato)
pos_aux = self.buscar_vertice(dato[1][0])
vertice_aux = self.inicio.obtener_elemento(pos_aux)
aristas = 0
while (aristas < vertice_aux['aristas'].tamanio()):
arista = vertice_aux['aristas'].obtener_elemento(aristas)
pos_heap = no_visitados.busqueda(arista['destino'])
if (pos_heap is not None
and no_visitados.elementos[pos_heap][0] >
dato[0] + arista['peso']):
no_visitados.elementos[pos_heap][1][1] = dato[1][0]
nuevo_peso = dato[0] + arista['peso']
no_visitados.cambiar_prioridad(pos_heap, nuevo_peso)
aristas += 1
# print(no_visitados.elementos)
return camino
def busqueda_prim(self, bosque, buscado):
for elemento in bosque:
if (buscado in elemento[1]):
return elemento
def prim(self):
"""Algoritmo de Prim para hallar el árbol de expansión mínimo."""
bosque = []
aristas = HeapMin()
origen = self.inicio.obtener_elemento(0)
adyac = 0
while (adyac < origen['aristas'].tamanio()):
arista = origen['aristas'].obtener_elemento(adyac)
aristas.arribo([origen['info'], arista['destino']], arista['peso'])
adyac += 1
# print(bosque)
# print(aristas.elementos)
# print()
while (len(bosque) // 2 < self.tamanio() and not aristas.vacio()):
dato = aristas.atencion()
if (len(bosque) == 0) or (
(self.busqueda_prim(bosque, dato[1][0]) is not None) ^
(self.busqueda_prim(bosque, dato[1][1]) is not None)):
bosque.append(dato)
pos_vertice = self.buscar_vertice(dato[1][1])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
adyac = 0
while (adyac < nuevo_vertice['aristas'].tamanio()):
arista = nuevo_vertice['aristas'].obtener_elemento(adyac)
# print(arista)
aristas.arribo([nuevo_vertice['info'], arista['destino']],
arista['peso'])
adyac += 1
# print(bosque)
# print(aristas.elementos)
# a = input()
return bosque
lista_pers.obtener_elemento(posScarlet)['Nombre'] = 'Scarlet Witch'
#C
for elementos in Personajes_aux:
lista_aux.insertar(elementos, 'Nombre')
for i in range(0, lista_aux.tamanio()):
lista_pers.insertar(lista_aux.obtener_elemento(i), 'Nombre')
#D
for i in reversed(range(lista_pers.tamanio())):
print(lista_pers.obtener_elemento(i))
#E
print('Personaje posicion 7 :', lista_pers.obtener_elemento(7)['Nombre'])
#F
for i in range(0, lista_pers.tamanio()):
x = lista_pers.obtener_elemento(i)
if (x['Nombre'][0] == "C"):
print('Los nombres que empiezan con la letra C son: ', x['Nombre'])
for i in range(0, lista_pers.tamanio()):
x = lista_pers.obtener_elemento(i)
if (x['Nombre'][0] == "S"):
print('Los nombres que empiezan con la letra S son: ', x['Nombre'])
#G
Lista2.barrido() #barrido año
lista_pers.barrido()
b. concatenar dos listas en una sola omitiendo los datos repetidos y manteniendo su orden;
c. contar cuántos elementos repetidos hay entre dos listas, es decir la intersección de ambas;[113]
d. eliminar todos los nodos de una lista de a uno a la vez mostrando su contenido """
from lista import Lista
from random import randint
primer_lista = Lista()
segunda_lista = Lista()
lista_concatenada = Lista()
for i in range(5):
primer_lista.insertar(i) #cargamos las dos listas
segunda_lista.insertar(randint(1,10))
print('lista uno')
primer_lista.barrido()
print()
print('lista dos')
segunda_lista.barrido()
print()
cont_repetidos = 0
for i in range(primer_lista.tamanio()): #puntoA
numero = (segunda_lista).obtener_elemento(i)
primer_lista.insertar(numero)
print('listas concatenadas')
primer_lista.barrido()
class Grafo(object):
def __init__(self, dirigido=True):
self.dirigido = dirigido
self.inicio = Lista()
def insertar_vertice(self, dato, criterio='info', data=None):
self.inicio.insertar(
{
'info': dato,
'visitado': False,
'aristas': Lista(),
'data': data
}, criterio)
def insertar_arista(self,
peso,
origen,
destino,
criterio='destino',
data=None):
ver_origen = self.inicio.busqueda(origen, 'info')
ver_destino = self.inicio.busqueda(destino, 'info')
if (ver_origen != -1 and ver_destino != -1):
self.inicio.obtener_elemento(ver_origen)['aristas'].insertar(
{
'peso': peso,
'destino': destino,
'data': data
}, criterio)
if (not self.dirigido):
self.inicio.obtener_elemento(ver_destino)['aristas'].insertar(
{
'peso': peso,
'destino': origen,
'data': data
}, criterio)
else:
print('Los vertices origen o destino no estan en el grafo.',
origen, destino)
def grafo_vacio(self):
return self.inicio.lista_vacia()
def tamanio(self):
return self.inicio.tamanio()
def buscar_vertice(self, clave, criterio='info'):
"""Devuelve la posicion del vertice buscando la clave dada en la lista de vértices."""
return self.inicio.busqueda(clave, criterio=criterio)
def buscar_arista(self, origen, destino, criterio='destino'):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
return self.inicio.obtener_elemento(
ver_origen)['aristas'].busqueda(destino, criterio)
else:
return ver_origen
def barrido_vertices(self):
"""Realiza un barrido de los vértices del grafo con la información completa de cada uno."""
self.inicio.barrido()
def es_adyacente(self, origen, destino):
"""Devuelve si un vertice es adyacente (tiene relacion directa) a otro."""
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
destino = self.buscar_arista(origen, destino)
if (destino != -1):
return True
else:
return False
else:
return False
def adyacentes(self, origen):
"""Barrido de todos los vertices adyacentes (que tienen relacion directa) a un vertice dado."""
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
self.inicio.obtener_elemento(ver_origen)['aristas'].barrido()
def eliminar_vertice(self, clave):
aux = self.inicio.eliminar(clave, criterio='info')
for posicion in range(self.tamanio()):
origen = self.inicio.obtener_elemento(posicion)['info']
self.eliminar_arista(origen, clave)
return aux
def eliminar_arista(self, origen, destino):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
self.inicio.obtener_elemento(ver_origen)['aristas'].eliminar(
destino, 'destino')
if (not self.dirigido):
ver_destino = self.inicio.busqueda(destino, 'info')
if (ver_destino != -1):
self.inicio.obtener_elemento(
ver_destino)['aristas'].eliminar(origen, 'destino')
def barrido_profundidad(self, ver_origen):
"""Barrido en profundidad del grafo."""
while (ver_origen < self.inicio.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
print(vertice['info'])
aristas = 0
while (aristas < vertice['aristas'].tamanio()):
arista = vertice['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(arista['destino'])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
if (not nuevo_vertice['visitado']):
self.barrido_profundidad(pos_vertice)
aristas += 1
ver_origen += 1
def barrido_amplitud(self, ver_origen):
"""Barrido en amplitud del grafo."""
cola = Cola()
while (ver_origen < self.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
cola.arribo(vertice)
while (not cola.cola_vacia()):
nodo = cola.atencion()
print(nodo['info'])
aristas = 0
while (aristas < nodo['aristas'].tamanio()):
adyacente = nodo['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(adyacente['destino'])
nuevo_vertice = self.inicio.obtener_elemento(
pos_vertice)
if (not nuevo_vertice['visitado']):
nuevo_vertice['visitado'] = True
cola.arribo(nuevo_vertice)
aristas += 1
ver_origen += 1
def marcar_no_visitado(self):
for i in range(self.tamanio()):
self.inicio.obtener_elemento(i)['visitado'] = False
def existe_paso(self, ver_origen, ver_destino):
"""Devuelve verdadero (true) si es posible ir desde el vértice origen hasta el vértice destino, caso contrario retornará falso (false);"""
resultado = False
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
aristas = 0
while (aristas < vertice['aristas'].tamanio() and not resultado):
arista = vertice['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(arista['destino'])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
destino = self.inicio.obtener_elemento(ver_destino)
if (nuevo_vertice['info'] == destino['info']):
return True
else:
resultado = self.existe_paso(pos_vertice, ver_destino)
aristas += 1
return resultado
def dijkstra(self, ver_origen, ver_destino):
"""Algoritmo de Dijkstra para hallar el camino mas corto."""
no_visitados = HeapMin()
camino = Pila()
aux = 0
while (aux < self.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
vertice_aux = self.inicio.obtener_elemento(aux)
vertice_aux['anterior'] = None
if (vertice_aux['info'] == vertice['info']):
no_visitados.arribo([vertice_aux['info'], None], 0)
else:
no_visitados.arribo([vertice_aux['info'], None], inf)
aux += 1
while (not no_visitados.vacio()):
dato = no_visitados.atencion()
camino.apilar(dato)
pos_aux = self.buscar_vertice(dato[1][0])
vertice_aux = self.inicio.obtener_elemento(pos_aux)
aristas = 0
while (aristas < vertice_aux['aristas'].tamanio()):
arista = vertice_aux['aristas'].obtener_elemento(aristas)
pos_heap = no_visitados.busqueda(arista['destino'])
if (pos_heap is not None
and no_visitados.elementos[pos_heap][0] >
dato[0] + arista['peso']):
no_visitados.elementos[pos_heap][1][1] = dato[1][0]
nuevo_peso = dato[0] + arista['peso']
no_visitados.cambiar_prioridad(pos_heap, nuevo_peso)
aristas += 1
# print(no_visitados.elementos)
return camino
def busqueda_prim(self, bosque, buscado):
for elemento in bosque:
if (buscado in elemento[1]):
return elemento
def prim(self, inicio=0):
"""Algoritmo de Prim para hallar el árbol de expansión mínimo."""
bosque = []
aristas = HeapMin()
origen = self.inicio.obtener_elemento(inicio)
adyac = 0
while (adyac < origen['aristas'].tamanio()):
arista = origen['aristas'].obtener_elemento(adyac)
aristas.arribo([origen['info'], arista['destino']], arista['peso'])
adyac += 1
while (len(bosque) // 2 < self.tamanio() and not aristas.vacio()):
dato = aristas.atencion()
if (len(bosque) == 0) or (
(self.busqueda_prim(bosque, dato[1][0]) is not None) ^
(self.busqueda_prim(bosque, dato[1][1]) is not None)):
bosque.append(dato)
pos_vertice = self.buscar_vertice(dato[1][1])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
adyac = 0
while (adyac < nuevo_vertice['aristas'].tamanio()):
arista = nuevo_vertice['aristas'].obtener_elemento(adyac)
aristas.arribo([nuevo_vertice['info'], arista['destino']],
arista['peso'])
adyac += 1
return bosque
#! ----- COMIENZO FUNCIONES EJERCICIO 06 GUIA DE EJERCICIOS ----- #!
def hijos_dios(self, nombre_dios):
"""Devuelve una lista con los hijos del dios dado o None si el dios ingresado no está cargado."""
hijos = []
dios = self.buscar_vertice(nombre_dios)
if (dios != -1):
aristas = self.inicio.obtener_elemento(dios)['aristas']
for i in range(aristas.tamanio()):
elemento = aristas.obtener_elemento(i)
if (elemento['data'] == 'padre'
or elemento['data'] == 'madre'):
hijos.append(elemento['destino'])
return hijos
else:
return None
def familia_dios(self, nombre_dios):
"""Funcion que devuelve tres listas (padres, hijos y hermanos) en base al dios dado,
o None si el dios ingresado no está cargado."""
dios = self.buscar_vertice(nombre_dios)
if (dios != -1):
padres = []
hijos = []
hermanos = []
aristas = self.inicio.obtener_elemento(dios)['aristas']
for i in range(aristas.tamanio()):
elemento = aristas.obtener_elemento(i)
if (elemento['data'] == 'hijo/a'):
padres.append(elemento['destino'])
elif (elemento['data'] == 'padre'
or elemento['data'] == 'madre'):
hijos.append(elemento['destino'])
elif (elemento['data'] == 'hermano/a'):
hermanos.append(elemento['destino'])
return padres, hijos, hermanos
else:
return None, None, None
def relacion_dioses(self, vertice_origen, vertice_destino):
"""Devuelve una lista con la/s relacion/es encontradas entre dos dioses, una lista vacia si no existe relacion."""
relacion = []
if (self.es_adyacente(vertice_origen, vertice_destino)):
dios = self.buscar_vertice(vertice_origen)
aristas = self.inicio.obtener_elemento(dios)['aristas']
for i in range(aristas.tamanio()):
elemento = aristas.obtener_elemento(i)
if (vertice_destino == elemento['destino']):
relacion.append(elemento['data'])
return relacion
def madre_dios(self, nombre_dios):
"""Recorre lista de aristas de un dios y devuelve el nombre de su madre, o None si no tiene."""
dios = self.buscar_vertice(nombre_dios)
aristas = self.inicio.obtener_elemento(dios)['aristas']
madre = None
for i in range(aristas.tamanio()):
elemento = aristas.obtener_elemento(i)
if (elemento['data'] == 'hijo/a'):
pos = self.buscar_vertice(elemento['destino'])
if (
self.inicio.obtener_elemento(
pos)['data']['genero'] == 'F'
): #se verifica que el genero sea F para que no muestre al padre
madre = elemento['destino']
return madre #devuelve None si el dios no tiene madre
def barrido_profundidad_dioses_madres(self, ver_origen):
"""Barrido en profundidad del grafo mostrando solo a los dioses que tienen madres, utilizando la funcion madre_dios."""
while (ver_origen < self.inicio.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
madre = self.madre_dios(vertice['info'])
if (not madre == None
): #para mostrar unicamente a los dioses que tienen madre
print(vertice['info'], ' - Madre:', madre)
aristas = 0
while (aristas < vertice['aristas'].tamanio()):
arista = vertice['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(arista['destino'])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
if (not nuevo_vertice['visitado']):
self.barrido_profundidad_dioses_madres(pos_vertice)
aristas += 1
ver_origen += 1
def ancestros_dios(self, nombre_dios, ancestros):
"""Carga en la lista dada los nombres de los ancestros del dios dado."""
dios = self.buscar_vertice(nombre_dios)
aristas = self.inicio.obtener_elemento(dios)['aristas']
for i in range(aristas.tamanio()):
elemento = aristas.obtener_elemento(i)
if (elemento['data'] == 'hijo/a'):
if (elemento['destino'] not in ancestros):
ancestros.append(elemento['destino'])
self.ancestros_dios(elemento['destino'], ancestros)
def nietos_dios(self, nombre_dios):
"""Devuelve una lista con los nietos de un dios dado accediendo a los hijos de éste
y usando hijos_dios para agregar a los hijos de cada uno a la lista de nietos."""
nietos = []
dios = self.buscar_vertice(nombre_dios)
aristas = self.inicio.obtener_elemento(dios)['aristas']
for i in range(aristas.tamanio()):
elemento = aristas.obtener_elemento(i)
if (elemento['data'] == 'padre' or elemento['data'] == 'madre'):
hijos = self.hijos_dios(elemento['destino'])
for i in range(len(hijos)):
if hijos[i] not in nietos:
nietos.append(hijos[i])
return nietos
},
{
'nombre': 'Rocket Racoonn',
'Año de aparicion': 2014,
'Heroe': True
},
{
'nombre': 'Loki',
'Año de aparicion': 2011,
'Heroe': False
},
]
for marvel in lista2:
lista_auxiliar.insertar(marvel, 'nombre')
lista_marvel.barrido()
print()
#punto A
pos = lista_marvel.busqueda('Thor', 'nombre')
if (pos != -1):
print('Thor esta en la posicion', pos)
else:
print('Thor no esta en la lista')
print()
#punto B
pos = lista_marvel.busqueda('Scalet Witch', 'nombre')
if (pos != -1):
lista_marvel.obtener_elemento(pos)['nombre'] = 'Scarlet Witch'
print()
class Grafo(object):
def __init__(self, dirigido=True):
self.dirigido = dirigido
self.inicio = Lista()
def insertar_vertice(self, dato, criterio='info', data=None):
self.inicio.insertar(
{
'info': dato,
'visitado': False,
'aristas': Lista(),
'data': data
}, criterio)
def insertar_arista(self,
peso,
origen,
destino,
criterio='destino',
data=None):
ver_origen = self.inicio.busqueda(origen, 'info')
ver_destino = self.inicio.busqueda(destino, 'info')
if (ver_origen != -1 and ver_destino != -1):
self.inicio.obtener_elemento(ver_origen)['aristas'].insertar(
{
'peso': peso,
'destino': destino,
'data': data
}, criterio)
if (not self.dirigido):
self.inicio.obtener_elemento(ver_destino)['aristas'].insertar(
{
'peso': peso,
'destino': origen,
'data': data
}, criterio)
else:
print('Los vertices origen o destino no estan en el grafo.',
origen, destino)
def grafo_vacio(self):
return self.inicio.lista_vacia()
def tamanio(self):
return self.inicio.tamanio()
def buscar_vertice(self, clave, criterio='info'):
return self.inicio.busqueda(clave, criterio=criterio)
def buscar_arista(self, origen, destino, criterio='destino'):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
return self.inicio.obtener_elemento(
ver_origen)['aristas'].busqueda(destino, criterio)
else:
return ver_origen
def barrido_vertices(self):
self.inicio.barrido()
def es_adyacente(self, origen, destino):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
destino = self.buscar_arista(origen, destino)
if (destino != -1):
return True
else:
return False
else:
return False
def adyacentes(self, origen):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
self.inicio.obtener_elemento(ver_origen)['aristas'].barrido()
def eliminar_vertice(self, clave):
aux = self.inicio.eliminar(clave, criterio='info')
for posicion in range(self.tamanio()):
origen = self.inicio.obtener_elemento(posicion)['info']
self.eliminar_arista(origen, clave)
return aux
def eliminar_arista(self, origen, destino):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
self.inicio.obtener_elemento(ver_origen)['aristas'].eliminar(
destino, 'destino')
if (not self.dirigido):
ver_destino = self.inicio.busqueda(destino, 'info')
if (ver_destino != -1):
self.inicio.obtener_elemento(
ver_destino)['aristas'].eliminar(origen, 'destino')
def barrido_profundidad(self, ver_origen):
while (ver_origen < self.inicio.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
print(vertice['info'])
aristas = 0
while (aristas < vertice['aristas'].tamanio()):
arista = vertice['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(arista['destino'])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
if (not nuevo_vertice['visitado']):
self.barrido_profundidad(pos_vertice)
aristas += 1
ver_origen += 1
def barrido_amplitud(self, ver_origen):
cola = Cola()
while (ver_origen < self.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
cola.arribo(vertice)
while (not cola.cola_vacia()):
nodo = cola.atencion()
print(nodo['info'])
aristas = 0
while (aristas < nodo['aristas'].tamanio()):
adyacente = nodo['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(adyacente['destino'])
nuevo_vertice = self.inicio.obtener_elemento(
pos_vertice)
if (not nuevo_vertice['visitado']):
nuevo_vertice['visitado'] = True
cola.arribo(nuevo_vertice)
aristas += 1
ver_origen += 1
def marcar_no_visitado(self):
for i in range(self.tamanio()):
self.inicio.obtener_elemento(i)['visitado'] = False
def existe_paso(self, ver_origen, ver_destino):
resultado = False
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
aristas = 0
while (aristas < vertice['aristas'].tamanio() and not resultado):
arista = vertice['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(arista['destino'])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
destino = self.inicio.obtener_elemento(ver_destino)
if (nuevo_vertice['info'] == destino['info']):
return True
else:
resultado = self.existe_paso(pos_vertice, ver_destino)
aristas += 1
return resultado
def dijkstra(self, ver_origen, ver_destino):
no_visitados = HeapMin()
camino = Pila()
aux = 0
while (aux < self.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
vertice_aux = self.inicio.obtener_elemento(aux)
vertice_aux['anterior'] = None
if (vertice_aux['info'] == vertice['info']):
no_visitados.arribo([vertice_aux['info'], None], 0)
else:
no_visitados.arribo([vertice_aux['info'], None], inf)
aux += 1
while (not no_visitados.vacio()):
dato = no_visitados.atencion()
camino.apilar(dato)
pos_aux = self.buscar_vertice(dato[1][0])
vertice_aux = self.inicio.obtener_elemento(pos_aux)
aristas = 0
while (aristas < vertice_aux['aristas'].tamanio()):
arista = vertice_aux['aristas'].obtener_elemento(aristas)
pos_heap = no_visitados.busqueda(arista['destino'])
if (pos_heap is not None
and no_visitados.elementos[pos_heap][0] >
dato[0] + arista['peso']):
no_visitados.elementos[pos_heap][1][1] = dato[1][0]
nuevo_peso = dato[0] + arista['peso']
no_visitados.cambiar_prioridad(pos_heap, nuevo_peso)
aristas += 1
return camino
def busqueda_prim(self, bosque, buscado):
for elemento in bosque:
if (buscado in elemento[1]):
return elemento
def prim(self, inicio=0):
bosque = []
aristas = HeapMin()
origen = self.inicio.obtener_elemento(inicio)
adyac = 0
while (adyac < origen['aristas'].tamanio()):
arista = origen['aristas'].obtener_elemento(adyac)
aristas.arribo([origen['info'], arista['destino']], arista['peso'])
adyac += 1
while (len(bosque) // 2 < self.tamanio() and not aristas.vacio()):
dato = aristas.atencion()
if (len(bosque) == 0) or (
(self.busqueda_prim(bosque, dato[1][0]) is not None) ^
(self.busqueda_prim(bosque, dato[1][1]) is not None)):
bosque.append(dato)
pos_vertice = self.buscar_vertice(dato[1][1])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
adyac = 0
while (adyac < nuevo_vertice['aristas'].tamanio()):
arista = nuevo_vertice['aristas'].obtener_elemento(adyac)
aristas.arribo([nuevo_vertice['info'], arista['destino']],
arista['peso'])
adyac += 1
return bosque
def camino_mas_corto(self, ver_origen, ver_destino):
vertice_origen = self.buscar_vertice(ver_destino)
vertice_destino = self.buscar_vertice(ver_origen)
pila_camino = self.dijkstra(vertice_origen, vertice_destino)
destino = ver_origen
costo = None
print('El camino mas corto desde', ver_origen, 'a', ver_destino, 'es:')
while (not pila_camino.pila_vacia()):
dato = pila_camino.desapilar()
if (dato[1][0] == destino):
if (costo is None):
costo = dato[0]
print(' - ', dato[1][0])
destino = dato[1][1]
print('El costo total del camino es:', costo)
def arbol_expansion_minimo(self, vertice_origen=0):
bosque = self.prim(vertice_origen)
peso = 0
print('Arbol de expansion minimo:')
for elemento in bosque:
print(' ', elemento[1][0], '-', elemento[1][1])
peso += elemento[0]
print('El costo total es', peso)
print()
lista2 = Lista()
lista_concatenada = Lista()
for i in range(0, 10):
lista1.insertar(i)
for i in range(0, 10):
lista2.insertar(i * 2)
for i in range(lista1.tamanio()):
lista_concatenada.insertar(lista1.obtener_elemento(i))
for i in range(lista2.tamanio()):
lista_concatenada.insertar(lista2.obtener_elemento(i))
print('Listas concatenadas:')
lista_concatenada.barrido()
print()
cont_repetido = 0
for i in range(lista2.tamanio()):
elemento = lista2.obtener_elemento(i)
pos = lista1.busqueda(elemento)
if pos == -1:
lista1.insertar(elemento)
else:
cont_repetido += 1
print('Listas concatenadas sin valores repetidos:')
lista1.barrido()
print()
for personaje in personajes:
lista1.insertar(personaje)
for personaje in personajes_auxiliar:
if (lista1.busqueda(personaje) == -1):
lista1.insertar(personaje)
posicion_thor = lista1.busqueda('Thor')
if (posicion_thor != -1):
print('Thor se encuentra en la posicion numero', posicion_thor,
'de la lista')
posicion = lista1.busqueda('Scalet Witch')
lista1.modificar_elemento(posicion, 'Scarlet Witch')
lista1.barrido() # Punto D
lista1.barrido_inverso() # Punto D
lista1.obtener_elemento(7) # Punto E
lista1.barrido_iniciales() # Punto F
personajes_completos = [{
'name': 'Thor',
'año': 1983,
'heroe': True
}, {
'name': 'Iron Man',
'año': 1970,
'heroe': True
}, {
#a
posicionthor = lista_personajes.busqueda('Thor','name')
if (posicionthor != -1):
print ('Thor esta en la posicion ',posicionthor)
else:
print ('Thor no esta en la lista')
#b
posScalet= lista_personajes.busqueda('Scalet Witch','name')
lista_personajes.obtener_elemento(posScalet)['name']= 'Scarlet Witch'
#d Ascendente
lista_personajes.barrido()
print("----------------------------------")
lista_personajes.barrido_Descendente()
print('------------------------------------')
#e
while(not lista_personajes.lista_vacia()):
print(lista_personajes.(lista_personajes.obtener_elemento(7))
#f
for i in range(0,lista_personajes.tamanio()):
x = lista_personajes.obtener_elemento(i)
if (x['name'][0]=="C" or x['name'][0]=="S"):
print('Los nombres que empiezan con la letra C o S son: ',x['name'])
personajes_2 = [
]
for personaje in lista1:
lista_personaje.insertar(personaje,'name')
lista_auxiliar = [
{'name': 'Black Widow','Año de aparicion': 1989, 'Heroe': True},
{'name': 'Hulk','Año de aparicion': 1939, 'Heroe': True},
{'name': 'Rocket Racoonn','Año de aparicion': 1950, 'Heroe': True},
{'name': 'Loki','Año de aparicion': 500, 'Heroe': False},
]
for personaje in lista_auxiliar:
lista_personaje.insertar(personaje,'name')
lista_personaje.barrido()
print()
# #punto a
# pos = lista_personaje.busqueda('Thor','name')
# if (pos != -1):
# print('Thor esta en la posicion: ', pos,' de la lista')
# print()
###punto b
# pos2 = lista_personaje.busqueda('Scalet Witch','name')
# if (pos2 != -1):
# lista_personaje.obtener_elemento(pos2)['name'] = 'Scarlet Witch'
# print()
###punto d
class Grafo(object):
def __init__(self, dirigido=True):
self.dirigido = dirigido
self.inicio = Lista()
def insertar_vertice(self,
dato,
criterio='info',
data=None): # ! agregar otro
self.inicio.insertar(
{
'info': dato,
'visitado': False,
'aristas': Lista(),
'data': data
}, criterio)
def insertar_arista(self,
peso,
origen,
destino,
criterio='destino',
data=None): # ! agregar otro
ver_origen = self.inicio.busqueda(origen, 'info')
ver_destino = self.inicio.busqueda(destino, 'info')
if (ver_origen != -1 and ver_destino != -1):
self.inicio.obtener_elemento(ver_origen)['aristas'].insertar(
{
'peso': peso,
'destino': destino,
'data': data
}, criterio)
if (not self.dirigido and origen != destino):
data_aux = deepcopy(data)
if (data):
data_aux['relacion'].reverse()
self.inicio.obtener_elemento(ver_destino)['aristas'].insertar(
{
'peso': peso,
'destino': origen,
'data': data_aux
}, criterio)
else:
print('los vertices origen o destino no estan en el grafo....',
origen, destino)
def grafo_vacio(self):
return self.inicio.lista_vacia()
def tamanio(self):
return self.inicio.tamanio()
def buscar_vertice(self, clave, criterio='info'):
return self.inicio.busqueda(clave, criterio=criterio)
def buscar_arista(self, origen, destino, criterio='destino'):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
return self.inicio.obtener_elemento(
ver_origen)['aristas'].busqueda(destino, criterio)
else:
return ver_origen
def barrido_vertices(self):
self.inicio.barrido()
def es_adyacente(self, origen, destino):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
destino = self.buscar_arista(origen, destino)
if (destino != -1):
return True
else:
return False
else:
return False
def adyacentes(self, origen):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
self.inicio.obtener_elemento(ver_origen)['aristas'].barrido()
def eliminar_vertice(self, clave):
aux = self.inicio.eliminar(clave, criterio='info')
for posicion in range(self.tamanio()):
origen = self.inicio.obtener_elemento(posicion)['info']
self.eliminar_arista(origen, clave)
return aux
def eliminar_arista(self, origen, destino):
ver_origen = self.inicio.busqueda(origen, 'info')
if (ver_origen != -1):
self.inicio.obtener_elemento(ver_origen)['aristas'].eliminar(
destino, 'destino')
if (not self.dirigido):
ver_destino = self.inicio.busqueda(destino, 'info')
if (ver_destino != -1):
self.inicio.obtener_elemento(
ver_destino)['aristas'].eliminar(origen, 'destino')
def barrido_profundidad(self, ver_origen):
"""Barrido en profundidad del grafo."""
while (ver_origen < self.inicio.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
print(vertice['info'])
aristas = 0
while (aristas < vertice['aristas'].tamanio()):
arista = vertice['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(arista['destino'])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
if (not nuevo_vertice['visitado']):
self.barrido_profundidad(pos_vertice)
aristas += 1
ver_origen += 1
def barrido_amplitud(self, ver_origen):
"""Barrido en amplitud del grafo."""
cola = Cola()
while (ver_origen < self.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
cola.arribo(vertice)
while (not cola.cola_vacia()):
nodo = cola.atencion()
print(nodo['info'], nodo['data'])
aristas = 0
while (aristas < nodo['aristas'].tamanio()):
adyacente = nodo['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(adyacente['destino'])
nuevo_vertice = self.inicio.obtener_elemento(
pos_vertice)
if (not nuevo_vertice['visitado']):
nuevo_vertice['visitado'] = True
cola.arribo(nuevo_vertice)
aristas += 1
ver_origen += 1
def marcar_no_visitado(self):
"""Marca todos los vertices del grafo como no visitados."""
for i in range(self.tamanio()):
self.inicio.obtener_elemento(i)['visitado'] = False
def existe_paso(self, ver_origen, ver_destino):
"""Barrido en profundidad del grafo."""
resultado = False
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
aristas = 0
while (aristas < vertice['aristas'].tamanio() and not resultado):
arista = vertice['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(arista['destino'])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
destino = self.inicio.obtener_elemento(ver_destino)
if (nuevo_vertice['info'] == destino['info']):
return True
else:
resultado = self.existe_paso(pos_vertice, ver_destino)
aristas += 1
return resultado
def dijkstra(self, ver_origen):
"""Algoritmo de Dijkstra para hallar el camino mas corto."""
no_visitados = HeapMin()
camino = Pila()
aux = 0
while (aux < self.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
vertice_aux = self.inicio.obtener_elemento(aux)
vertice_aux['anterior'] = None
if (vertice_aux['info'] == vertice['info']):
no_visitados.arribo([vertice_aux['info'], None], 0)
else:
no_visitados.arribo([vertice_aux['info'], None], inf)
aux += 1
while (not no_visitados.vacio()):
dato = no_visitados.atencion()
camino.apilar(dato)
pos_aux = self.buscar_vertice(dato[1][0])
vertice_aux = self.inicio.obtener_elemento(pos_aux)
aristas = 0
while (aristas < vertice_aux['aristas'].tamanio()):
arista = vertice_aux['aristas'].obtener_elemento(aristas)
pos_heap = no_visitados.busqueda(arista['destino'])
if (pos_heap is not None
and no_visitados.elementos[pos_heap][0] >
dato[0] + arista['peso']):
no_visitados.elementos[pos_heap][1][1] = dato[1][0]
nuevo_peso = dato[0] + arista['peso']
no_visitados.cambiar_prioridad(pos_heap, nuevo_peso)
aristas += 1
# print(no_visitados.elementos)
return camino
def busqueda_prim(self, bosque, buscado):
for elemento in bosque:
if (buscado in elemento[1]):
return elemento
def prim(self, inicio=0):
"""Algoritmo de Prim para hallar el árbol de expansión mínimo."""
bosque = []
aristas = HeapMin()
origen = self.inicio.obtener_elemento(inicio)
adyac = 0
while (adyac < origen['aristas'].tamanio()):
arista = origen['aristas'].obtener_elemento(adyac)
aristas.arribo([origen['info'], arista['destino']], arista['peso'])
adyac += 1
# print(bosque)
# print(aristas.elementos)
# print()
while (len(bosque) // 2 < self.tamanio() and not aristas.vacio()):
dato = aristas.atencion()
if (len(bosque) == 0) or (
(self.busqueda_prim(bosque, dato[1][0]) is not None) ^
(self.busqueda_prim(bosque, dato[1][1]) is not None)):
bosque.append(dato)
pos_vertice = self.buscar_vertice(dato[1][1])
nuevo_vertice = self.inicio.obtener_elemento(pos_vertice)
adyac = 0
while (adyac < nuevo_vertice['aristas'].tamanio()):
arista = nuevo_vertice['aristas'].obtener_elemento(adyac)
# print(arista)
aristas.arribo([nuevo_vertice['info'], arista['destino']],
arista['peso'])
adyac += 1
# print(bosque)
# print(aristas.elementos)
# a = input()
return bosque
# grafo = Grafo()
# grafo.insertar_vertice('A')
# grafo.insertar_vertice('C')
# grafo.insertar_vertice('B')
# grafo.insertar_vertice('F')
# grafo.insertar_vertice('Z')
# grafo.insertar_vertice('X')
# grafo.insertar_arista(5, 'A', 'B')
# grafo.insertar_arista(2, 'C', 'B')
# grafo.insertar_arista(3, 'B', 'C')
# grafo.insertar_arista(9, 'A', 'F')
# grafo.insertar_arista(5, 'B', 'F')
# grafo.insertar_arista(13, 'F', 'X')
# grafo.insertar_arista(7, 'X', 'Z')
# grafo.insertar_arista(5, 'C', 'X')
# vertice_destino = grafo.buscar_vertice('Z')
# vertice_origen = grafo.buscar_vertice('A')
# bosque = grafo.prim()
# print('arbol de expansion')
# peso = 0
# for elemento in bosque:
# print(elemento[1][0], '-', elemento[1][1])
# peso += elemento[0]
# print('costo total', peso)
# pila_camino = grafo.dijkstra(vertice_origen, vertice_destino)
# destino = 'Z'
# costo = None
# while(not pila_camino.pila_vacia()):
# dato = pila_camino.desapilar()
# if(dato[1][0] == destino):
# if(costo is None):
# costo = dato[0]
# print(dato[1][0])
# destino = dato[1][1]
# print('el costo total del camino es:', costo)
# print(grafo.existe_paso(vertice_origen, vertice_destino))
# grafo.barrido_profundidad(vertice_origen)
# grafo.marcar_no_visitado()
# print()
# vertice_origen = grafo.buscar_vertice('F')
# grafo.barrido_amplitud(vertice_origen)
# grafo.insertar_arista(100, 'B', 'B')
# grafo.inicio.obtener_elemento(0)['aristas'].barrido()
# print()
# grafo.inicio.obtener_elemento(1)['aristas'].barrido()
# grafo.barrido_vertices()
# print(grafo.es_adyacente('A', 'F'))
# print(grafo.es_adyacente('A', 'C'))
# # print(grafo.eliminar_vertice('B'))
# print()
# grafo.barrido_vertices()
# print()
# grafo.eliminar_arista('A', 'B')
# grafo.adyacentes('A')
# print()
# grafo.adyacentes('F')
# print()
# grafo.adyacentes('B')
# print(grafo.buscar_vertice('F'))
# print(grafo.buscar_vertice('B'))
# print(grafo.buscar_arista('B','A'))
# print(grafo.buscar_arista('A','A'))
def cargar_dioses(self):
self.insertar_vertice('Gaia')
self.insertar_vertice('Urano')
self.insertar_vertice('Themis')
self.insertar_vertice('Minemosyne')
self.insertar_vertice('Hyperion')
self.insertar_vertice('Theia')
self.insertar_vertice('Crios')
self.insertar_vertice('Cronos')
self.insertar_vertice('Rhea')
self.insertar_vertice('Kdios')
self.insertar_vertice('Phoibe')
self.insertar_vertice('Iapetos')
self.insertar_vertice('Okeanos')
self.insertar_vertice('Tedds')
self.insertar_vertice('Helios')
self.insertar_vertice('Eos')
self.insertar_vertice('Selene')
self.insertar_vertice('Prometheus')
self.insertar_vertice('Epimetheus')
self.insertar_vertice('Atlas')
self.insertar_vertice('Pleione')
self.insertar_vertice('Hades')
self.insertar_vertice('Demeter')
self.insertar_vertice('Poseidon')
self.insertar_vertice('Hestia')
self.insertar_vertice('Hera')
self.insertar_vertice('Zeus')
self.insertar_vertice('Leto')
self.insertar_vertice('Semelle')
self.insertar_vertice('Maia')
self.insertar_vertice('Persephone')
self.insertar_vertice('Aphrodite')
self.insertar_vertice('Ares')
self.insertar_vertice('Hephaistos')
self.insertar_vertice('Athena')
self.insertar_vertice('Apollo')
self.insertar_vertice('Artemis')
self.insertar_vertice('Dionysos')
self.insertar_vertice('Hermes')
self.insertar_vertice('Penelopeia')
self.insertar_vertice('Phobos')
self.insertar_vertice('Deimos')
self.insertar_vertice('Eros')
self.insertar_vertice('Himeros')
self.insertar_vertice('Hermaphrodite')
self.insertar_vertice('Pan')
self.insertar_arista(1,
'Urano',
'Gaia',
data={'relacion': ['hijo', 'madre', 'pareja']})
self.insertar_arista(1,
'Urano',
'Themis',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Urano',
'Hyperion',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Urano',
'Theia',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Urano',
'Crios',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Urano',
'Cronos',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Urano',
'Rhea',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Urano',
'Iapetos',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Urano',
'Okeanos',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Urano',
'Tedds',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Gaia',
'Themis',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Gaia',
'Hyperion',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Gaia',
'Theia',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Gaia',
'Crios',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Gaia',
'Cronos',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Gaia',
'Rhea',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Gaia',
'Iapetos',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Gaia',
'Okeanos',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Gaia',
'Tedds',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Hyperion',
'Theia',
data={'relacion': ['pareja', 'hermano']})
self.insertar_arista(1,
'Hyperion',
'Helios',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Hyperion',
'Eos',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Hyperion',
'Selene',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Theia',
'Helios',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Theia',
'Eos',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Theia',
'Selene',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Iapetos',
'Prometheus',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Iapetos',
'Epimetheus',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Iapetos',
'Atlas',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Okeanos',
'Tedds',
data={'relacion': ['pareja', 'hermano']})
self.insertar_arista(1,
'Okeanos',
'Pleione',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Tedds',
'Pleione',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Cronos',
'Rhea',
data={'relacion': ['pareja', 'hermano']})
self.insertar_arista(1,
'Cronos',
'Hades',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Cronos',
'Demeter',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Cronos',
'Poseidon',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Cronos',
'Hestia',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Cronos',
'Hera',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Cronos',
'Zeus',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Rhea',
'Hades',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Rhea',
'Demeter',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Rhea',
'Poseidon',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Rhea',
'Hestia',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Rhea',
'Hera',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Rhea',
'Zeus',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Kdios',
'Phoibe',
data={'relacion': ['pareja', 'hermano']})
self.insertar_arista(1,
'Kdios',
'Leto',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Phoibe',
'Leto',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Atlas',
'Pleione',
data={'relacion': ['pareja', 'hermano']})
self.insertar_arista(1,
'Atlas',
'Maia',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Pleione',
'Maia',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Demeter',
'Zeus',
data={'relacion': ['pareja', 'hermano']})
self.insertar_arista(1,
'Demeter',
'Persephone',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Zeus',
'Persephone',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Hera',
'Zeus',
data={'relacion': ['pareja', 'hermano']})
self.insertar_arista(1,
'Hera',
'Ares',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Hera',
'Hephaistos',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Zeus',
'Ares',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Zeus',
'Hephaistos',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Zeus',
'Athena',
data={'relacion': ['pareja']})
self.insertar_arista(1, 'Zeus', 'Leto', data={'relacion': ['pareja']})
self.insertar_arista(1,
'Zeus',
'Apollo',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Zeus',
'Artemis',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Leto',
'Apollo',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Leto',
'Artemis',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Zeus',
'Semelle',
data={'relacion': ['pareja']})
self.insertar_arista(1,
'Zeus',
'Dionysos',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Semelle',
'Dionysos',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1, 'Zeus', 'Maia', data={'relacion': ['pareja']})
self.insertar_arista(1,
'Zeus',
'Hermes',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Maia',
'Hermes',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Hades',
'Persephone',
data={'relacion': ['pareja']})
self.insertar_arista(1,
'Aphrodite',
'Ares',
data={'relacion': ['pareja']})
self.insertar_arista(1,
'Aphrodite',
'Phobos',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Aphrodite',
'Deimos',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Aphrodite',
'Eros',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Aphrodite',
'Himeros',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Ares',
'Phobos',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Ares',
'Deimos',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Ares',
'Eros',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Ares',
'Himeros',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Aphrodite',
'Hephaistos',
data={'relacion': ['pareja']})
self.insertar_arista(1,
'Aphrodite',
'Hermes',
data={'relacion': ['pareja']})
self.insertar_arista(1,
'Aphrodite',
'Hermaphrodite',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Hermes',
'Hermaphrodite',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Hermes',
'Penelopeia',
data={'relacion': ['pareja']})
self.insertar_arista(1,
'Hermes',
'Pan',
data={'relacion': ['padre', 'hijo']})
self.insertar_arista(1,
'Penelopeia',
'Pan',
data={'relacion': ['madre', 'hijo']})
self.insertar_arista(1,
'Themis',
'Minemosyne',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Themis',
'Hyperion',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Themis',
'Theia',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Themis',
'Crios',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Themis',
'Cronos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Themis',
'Rhea',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Themis',
'Kdios',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Themis',
'Phoibe',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Themis',
'Iapetos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Themis',
'Okeanos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Themis',
'Tedds',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Minemosyne',
'Hyperion',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Minemosyne',
'Theia',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Minemosyne',
'Crios',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Minemosyne',
'Cronos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Minemosyne',
'Rhea',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Minemosyne',
'Kdios',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Minemosyne',
'Phoibe',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Minemosyne',
'Iapetos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Minemosyne',
'Okeanos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Minemosyne',
'Tedds',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hyperion',
'Crios',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hyperion',
'Cronos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hyperion',
'Rhea',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hyperion',
'Kdios',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hyperion',
'Phoibe',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hyperion',
'Iapetos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hyperion',
'Okeanos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hyperion',
'Tedds',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Theia',
'Cronos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Theia',
'Rhea',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Theia',
'Kdios',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Theia',
'Phoibe',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Theia',
'Iapetos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Theia',
'Okeanos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Theia',
'Tedds',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Cronos',
'Rhea',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Cronos',
'Kdios',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Cronos',
'Phoibe',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Cronos',
'Iapetos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Cronos',
'Okeanos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Cronos',
'Tedds',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Kdios',
'Phoibe',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Kdios',
'Iapetos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Kdios',
'Okeanos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Kdios',
'Tedds',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Phoibe',
'Iapetos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Phoibe',
'Okeanos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Phoibe',
'Tedds',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Iapetos',
'Okeanos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Iapetos',
'Tedds',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Okeanos',
'Tedds',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Helios',
'Eos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Helios',
'Selene',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Eos',
'Selene',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Prometheus',
'Epimetheus',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Prometheus',
'Atlas',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Epimetheus',
'Atlas',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hades',
'Demeter',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hades',
'Poseidon',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hades',
'Hestia',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hades',
'Hera',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hades',
'Zeus',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Demeter',
'Poseidon',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Demeter',
'Hestia',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Demeter',
'Hera',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Poseidon',
'Hestia',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Poseidon',
'Hera',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Poseidon',
'Zeus',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hestia',
'Hera',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Hestia',
'Zeus',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Ares',
'Hephaistos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Apollo',
'Artemis',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Phobos',
'Deimos',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Phobos',
'Eros',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Phobos',
'Himeros',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Deimos',
'Eros',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Deimos',
'Himeros',
data={'relacion': ['hermano']})
self.insertar_arista(1,
'Eros',
'Himeros',
data={'relacion': ['hermano']})
from random import randint
lista_vocales = Lista()
lista_num = Lista()
lista_par = Lista()
lista_impar = Lista()
lista_personas = Lista()
lista_uno = Lista()
lista_dos = Lista()
for i in range(5):
lista_uno.insertar(i)
lista_dos.insertar(randint(1, 10))
print('lista uno')
lista_uno.barrido()
print()
print('lista dos')
lista_dos.barrido()
print()
for i in range(lista_dos.tamanio()):
num = lista_dos.obtener_elemento(i)
if (lista_uno.busqueda(num) == -1):
lista_uno.insertar(num)
lista_uno.barrido()
for i in range(20):
lista_num.insertar(randint(1, 999))
# Ejercicio 3
from lista import Lista
personajes = [
"Hulk", "Black Widow", "Spider Man", "Thor", "Capitan America",
"Scalet Witch"
]
lista_auxiliar = ["Black Widow", "Hulk", "Rocket Racoon", "Loki"]
lista_personajes = Lista()
for personaje in personajes:
lista_personajes.insertar(personaje)
lista_personajes.barrido()
print()
print("Thor se encuentra en la posicion: ",
lista_personajes.busqueda("Thor")) #Punto A
print()
lista_personajes.modificar_elemento(lista_personajes.busqueda("Scalet Witch"),
"Scarlet Witch") #Punto B
lista_personajes.barrido()
print()
for personaje in lista_auxiliar: # Punto C
if (lista_personajes.busqueda(personaje) == -1):
lista_personajes.insertar(personaje)
print("Nueva lista con personajes auxiliares agregados:")
