class Vertice():

def __init__(self, dato):

self.dato = dato
self.listaAdyacentes = []

def getDato(self):
return self.dato

def setDato(self, dato):

self.dato = dato

def getListaAdyacentes(self):
return self.listaAdyacentes

def setListaAdyacentes(self, listaAdyacentes):

self.listaAdyacentes = listaAdyacentes

class Arista():
def __init__(self, origen, destino, peso):
self.origen = origen
self.destino = destino
self.peso = peso

def getOrigen(self):
return self.origen

def setOrigen(self, origen):

self.origen = origen

def getDestino(self):
return self.destino

def setDestino(self, destino):

self.destino = destino

def getPeso(self):
return self.peso

def setPeso(self, peso):

self.peso = peso

from collections import deque

from Modelo.Arista import Arista
from Modelo.Vertice import Vertice

class Grafo():
def __init__(self):
self.listaVertices = []
self.listaAristas = []
self.listaVisitados = []

def getListaVertices(self):
return self.listaVertices

def getListaAristas(self):
return self.listaAristas

def getListaVisitados(self):
return self.listaVisitados

def ingresarVertice(self, dato):

if self.verificarVertice(dato) is None:
self.listaVertices.append(Vertice(dato))

def verificarVertice(self, dato):

for vertice in self.listaVertices:
if dato == vertice.getDato():
return vertice
return None

def ingresarArista(self, origen, destino, peso):

if self.verificarArista(origen, destino) is None:
if self.verificarVertice(origen) is not None and
self.verificarVertice(destino) is not None:
self.listaAristas.append(Arista(origen, destino,
peso))

self.verificarVertice(origen).getListaAdyacentes().append(destino)

def verificarArista(self, origen, destino):

for arista in self.listaAristas:
if arista.getOrigen() == origen and arista.getDestino()
== destino:
return arista
return None

def profundidad(self, dato):

if dato in self.listaVisitados:
return
 else:
vertice = self.verificarVertice(dato)
if vertice is not None:
self.listaVisitados.append(vertice.getDato())
for dato in vertice.getListaAdyacentes():
self.profundidad(dato)

def amplitud(self, dato):

visitadosA = []
cola = deque()
vertice = self.verificarVertice(dato)

if vertice is not None:

cola.append(vertice)
visitadosA.append(dato)

while cola:
elemento = cola.popleft()
for adyacencias in elemento.getListaAdyacentes():
if adyacencias not in visitadosA:
vertice = self.verificarVertice(adyacencias)
cola.append(vertice)
visitadosA.append(adyacencias)
return visitadosA

def imprimirVertice(self):
for vertice in self.listaVertices:
print(vertice.getDato())

def imprimirArista(self):
for arista in self.listaAristas:
print('Origen: {0} -- Destino: {1} -- Peso:
{2}'.format(arista.getOrigen(), arista.getDestino(),
arista.getPeso()))

def imprimirListaAdyacentes(self):
for vertice in self.listaVertices:
print('Lista de adyacentes de ',vertice.getDato(),':
',vertice.getListaAdyacentes())