def push(self):
if self.vacia():
self.primero = NodoMatriz(0)
else:
nuevo = NodoMatriz(0)
nuevo.setSiguiente(self.primero)
self.primero = nuevo
def push(self):
if self.vacia():
self.primero = NodoMatriz(0)
else:
nuevo = NodoMatriz(0)
nuevo.setSiguiente(self.primero)
self.primero = nuevo
def agregarMedioMes(self, nodo1, nuevoNodo, nodo2):
nuevoNodo1 = NodoMatriz(str(nuevoNodo.mes), str(nuevoNodo.numeroMes),
"")
nodo1.derecha = nuevoNodo1
nuevoNodo1.izquierda = nodo1
nuevoNodo1.derecha = nodo2
nodo2.izquierda = nuevoNodo1
def agregarFinMes(self, nuevoNodo):
nuevoNodo1 = NodoMatriz(str(nuevoNodo.mes), str(nuevoNodo.numeroMes), "")
temp = self.inicioMes
while temp != None:
aux = temp
temp = temp.derecha
aux.derecha = nuevoNodo1
nuevoNodo1.izquierda = aux
def agregarFinAnio(self, nuevoNodo):
nuevoNodo1 = NodoMatriz("", "", str(nuevoNodo.anio))
temp = self.inicioAnio
while temp != None:
aux = temp
temp = temp.abajo
aux.abajo = nuevoNodo1
nuevoNodo1.arriba = aux
def insertar(
self, valor
): #Paso 1 Tiene todo que ver con las empresas (aqui se valida si existe, si va antes o despues); independientemente de lo
# que se haga siempre se devuelve el nodo con el nombre del dominio recibido
nodo = NodoMatriz()
nodo.valor = valor
aux = None #Esta variable me servira para retornar el nodo
if self.cabeza is None: #No existe ninguna empresa, inserto la empresa en la cabeza, le asigno ese nodo a aux y lo retorno
self.cabeza = nodo
aux = self.cabeza
else:
temp = self.cabeza
bandera = 0 #Esta variable me indicara si el dominio se agrega al final de las demas empresas
while (
temp is not None
): #While utilizado para recorrer de forma horizontal las empresas
nombresEmpresas = [temp.valor, valor]
nombresEmpresas.sort()
if temp.valor == valor: #si la empresa recibida ya existe me limito solo a igualarlo a aux para ser posteriormente retornado
aux = temp
bandera = 1
print("Esta empresa ya existe perro")
break
if (
nombresEmpresas.index(temp.valor) == 1
): #Si el nodo en el que estoy es mayor al que recibi significa que deberia
# insertar el nodo antes de este, por lo tanto lo hago y lo igualo a aux para ser retornado
if temp == self.cabeza: #Si el nodo mayor es la cabeza se hace una operacion especial
self.cabeza.anterior = nodo
self.cabeza.anterior.siguiente = self.cabeza
self.cabeza = nodo
aux = self.cabeza
print("Se cambio la cabeza")
else: #Si el nodo mayor es cualquier otro diferente a la cabeza se hace lo siguiente
temp.anterior.siguiente = nodo
temp.anterior.siguiente.anterior = temp.anterior
nodo.siguiente = temp
temp.anterior = nodo
aux = temp.anterior
print("Se cambio nodo diferente a cabeza")
bandera = 1
break
temp = temp.siguiente
if bandera == 1: #Bandera es igual a 1, significa que ya se creo el nodo, por lo tanto no se hace mas
print("")
else: # de lo contrario se agrega el dominio al final y se iguala a aux
temp = self.cabeza
while temp.siguiente is not None:
temp = temp.siguiente
temp.siguiente = nodo
temp.siguiente.anterior = temp
temp = temp.siguiente
aux = temp
print("Se ingreso al final")
return aux
def insertar(self, fila, columna, valor):
nuevo = NodoMatriz(fila, columna, valor)
#insesion filas
eFila = self.efilas.getEncabezado(fila)
if eFila == None:
eFila = NodoEncabezado(fila)
eFila.accesoNodo = nuevo
self.efilas.setEncabezado(eFila)
else:
if nuevo.columna < eFila.accesoNodo.columna:
nuevo.derecha = eFila.accesoNodo
eFila.accesoNodo.izquierda = nuevo
eFila.accesoNodo = nuevo
else:
actual = eFila.accesoNodo
while(actual.derecha != None):
if nuevo.columna < actual.derecha.columna:
nuevo.derecha = actual.derecha
actual.derecha.izquierda = nuevo
nuevo.izquierda = actual
actual.derecha = nuevo
break
actual = actual.derecha
if actual.derecha == None:
actual.derecha = nuevo
nuevo.izquierda = actual
#insersion columnas
eColumna = self.ecolumnas.getEncabezado(columna)
if eColumna == None:
eColumna = NodoEncabezado(columna)
eColumna.accesoNodo = nuevo
self.ecolumnas.setEncabezado(eColumna)
else:
if nuevo.fila < eColumna.accesoNodo.fila:
nuevo.abajo = eColumna.accesoNodo
eColumna.accesoNodo.arriba = nuevo
eColumna.accesoNodo = nuevo
else:
actual = eColumna.accesoNodo
while actual.abajo != None:
if nuevo.fila < actual.abajo.fila:
nuevo.abajo = actual.abajo
actual.abajo.arriba = nuevo
nuevo.arriba = actual
actual.abajo = nuevo
break
actual = actual.abajo
if actual.abajo == None:
actual.abajo = nuevo
nuevo.arriba =actual
def insertar1(
self, valor
): #Paso2 Tiene todo que ver con los departamentos (aqui se valida si existe, si va arriba o abajo); independientemente de lo
# que se haga siempre se devuelve el nodo con el nombre del departamento recibido
nodo = NodoMatriz()
nodo.valor = valor
aux = None #Esta variable me servira para retornar el nodo
if self.cabeza1 is None: #Si no existe ningun departamento lo agrego a la cabeza
self.cabeza1 = nodo
aux = self.cabeza1
else:
temp = self.cabeza1
bandera = 0 #Me servira para saber si debo de ingresar el nodo al final
while temp is not None: #utilizo este while para recorrer todos los nodos y validar algunos casos
nombresDepartamentos = [temp.valor, valor]
nombresDepartamentos.sort()
if temp.valor == valor: #Si ya existe un nodo con el departamento recibido solo igualo el nodo a aux
aux = temp
bandera = 1
print("Este departamento ya existe perro")
break
if (
nombresDepartamentos.index(temp.valor) == 1
): #Si existe algun nodo con inicial mayor al departamento recibido significa que el departamento recibido
#deberia ir arriba
if temp == self.cabeza1: #Si el departamento mayor es la cabeza se hace una operacion especial
self.cabeza1.arriba = nodo
self.cabeza1.arriba.abajo = self.cabeza1
self.cabeza1 = nodo
aux = self.cabeza1
print("Se inserto en la cabeza")
else: #de lo contrario se juega con los apuntadores para insertar el nodo enmedio
temp.arriba.abajo = nodo
temp.arriba.abajo.arriba = temp.arriba
nodo.abajo = temp
temp.arriba = nodo
aux = temp.arriba
print("Se inserto en cualquier otro lado")
bandera = 1
break
temp = temp.abajo
if bandera == 1: #Si entro en algunos casos ya no se hace nada
print("")
else: # de lo contrario se agrega al final y se asigna a aux para ser retornado
temp = self.cabeza1
while temp.abajo is not None:
temp = temp.abajo
temp.abajo = nodo
temp.abajo.arriba = temp
temp = temp.abajo
aux = temp
print("Se inserto al final")
return aux
class ListaFilaMatriz:
def __init__(self, anchura):
self.primero = None
for i in xrange(0, anchura):
self.push()
def getPrimero(self):
return self.primero
def isEmpty(self):
return self.primero == None
def push(self):
if self.isEmpty():
self.primero = NodoMatriz(0)
else:
nuevo = NodoMatriz(0)
nuevo.setSiguiente(self.primero)
self.primero.setAnterior(nuevo)
self.primero = nuevo
def CrearTablaHash():
try:
anio = str(request.form['anio'])
numeroMes = str(request.form['numeroMes'])
dia = str(request.form['dia'])
mes = claseMatriz.verMes(numeroMes)
nodoM = NodoMatriz(mes, numeroMes, anio, dia)
claseMatriz.graficarTablaHash(nodoM)
return "Archivo Tabla Hash Creado"
except:
return "Error en el Servidor"
def push(self):
if self.isEmpty():
self.primero = NodoMatriz(0)
else:
nuevo = NodoMatriz(0)
nuevo.setSiguiente(self.primero)
self.primero.setAnterior(nuevo)
self.primero = nuevo
def Agregar(self, fila, columna, valor):
nodoMatriz = NodoMatriz(valor, fila, columna)
if self.primero.fila.ExisteNodo(
fila, "fila") == False and self.primero.columna.ExisteNodo(
columna, "Columna") == False: #si existe e
nodoCabezacolumna = NodoEncabezado(columna)
nodoCabezafila = NodoEncabezado(fila)
nodoCabezacolumna.Nodo = nodoMatriz
nodoCabezafila.Nodo = nodoMatriz
self.primero.fila.Agregar(nodoCabezafila)
self.primero.columna.Agregar(nodoCabezacolumna)
elif self.primero.fila.ExisteNodo(
fila, "fila") and self.primero.columna.ExisteNodo(
columna, "columna") == False: #si existe el no
aux = self.primero.fila.Buscar(fila)
aux1 = aux.Nodo
nodoCabezacolumna = NodoEncabezado(columna)
nodoCabezacolumna.Nodo = nodoMatriz
self.primero.columna.Agregar(nodoCabezacolumna)
while aux1.siguiente != None:
aux1 = aux1.siguiente
aux1.siguiente = nodoMatriz
nodoMatriz.atras = aux1
elif self.primero.fila.ExisteNodo(
fila, "fila") == False and self.primero.columna.ExisteNodo(
columna, "columna"): #si existe el nodo
aux = self.primero.columna.Buscar(columna)
aux1 = aux.Nodo
nodoCabezaFila = NodoEncabezado(fila)
nodoCabezaFila.Nodo = nodoMatriz
self.primero.fila.Agregar(nodoCabezaFila)
while aux1.abajo != None:
aux1 = aux1.abajo
aux1.abajo = nodoMatriz
nodoMatriz.arriba = aux1
else:
auxiliar = self.primero.fila.Buscar(fila)
aux1 = auxiliar.Nodo
while aux1.siguiente != None:
aux1 = aux1.siguiente
aux1.siguiente = nodoMatriz
nodoMatriz.atras = aux1
aux = self.primero.columna.Buscar(columna)
au = aux.Nodo
while au.abajo != None:
au = au.abajo
au.abajo = nodoMatriz
nodoMatriz.arriba = au
def agregarReservacion():
usuario = str(request.form['usuario'])
habitacion = str(request.form['habitacion'])
tarjeta = str(request.form['tarjeta'])
monto = str(request.form['monto'])
anio = str(request.form['anio'])
numMes = str(request.form['mes'])
dia = str(request.form['dia'])
idfecha = str(request.form['idfecha'])
ingreso = str(request.form['ingreso'])
salida = str(request.form['salida'])
#_#################################################_termino de obtener los 10 parametros ara guardar en las Estructuras
codigo = int(habitacion)
nodoHash = NodoHash(codigo, usuario)#
mes = matriz.verMes(numMes)
matriz.aumentarContador()
codigo = str(matriz.obtenerContador())
nuevoNodo = NodoMatriz(mes, numMes, anio, dia, codigo)
matriz.agregarCabecerasMatriz(nuevoNodo)
if matriz.necesitaProfundidad(nuevoNodo) == True:
matriz.agregarProfundidad(nuevoNodo)
else:
matriz.agregarMatriz(nuevoNodo)
matriz.archivoMatriz()
matriz.agregarTablaHash(nuevoNodo, nodoHash)
matriz.graficarTablaHash(nuevoNodo)
#_#########################################################################_Matriz/Hash
nuevoNodoLista = NodoLista(tarjeta, monto)
arbolAVL.agregarListaAVL(nuevoNodoLista)
#_##########################################################################_AVL
descripcion = ("El usaurio "+usuario+" reservo la habitacion: "+habitacion+" gastando un monto de Q"+monto+".00, pago con la tarjeta: "+tarjeta+", fecha de ingreso: "+ingreso+" y fecha de salida: "+salida)
arbolB.crearNodoInsertar(idfecha, usuario, descripcion, ingreso, salida, habitacion, "si")
#_##########################################################################_B
listaHabitaciones.actualizarReservada(habitacion)
#_####_Actualizar Datos de Habitacion
return "operacion realizada con exito"
def Reservaciones():
try:
idReservacion = str(request.form['idReservacion'])
anio = str(request.form['anio'])
numeroMes = str(request.form['numeroMes'])
dia = str(request.form['dia'])
fechaReservacion = str(request.form['fechaReservacion'])
fechaSalida = str(request.form['fechaSalida'])
mes = claseMatriz.verMes(numeroMes)
usuario = str(request.form['usuario'])
numeroTarjeta = str(request.form['numeroTarjeta'])
totalGastado = str(request.form['totalGastado'])
claseMatriz.aumetarContador()
codigo = str(claseMatriz.obtenerContador())
nodoM = NodoMatriz(mes, numeroMes, anio, dia, codigo)
if claseMatriz.existeReservacion(nodoM) == False:
claseMatriz.agregarCabecerasMatriz(nodoM)
if claseMatriz.necesitaProfundidad(nodoM) == True:
claseMatriz.agregarProfundidad(nodoM)
else:
claseMatriz.agregarMatriz(nodoM)
nodoHash = NodoH(idReservacion, usuario)
claseMatriz.agregarTablaHash(nodoM, nodoHash)
idUsuario = claseListaDoble.retornarID(usuario)
claseArbolB.crearNodoInsertar(
int(fechaReservacion), usuario,
"Se Reservo la Habitacion: " + idReservacion + ", se Gasto " +
totalGastado + ", se pago con No. Tarjeta " + numeroTarjeta,
anio + numeroMes + dia, fechaSalida, idReservacion, "si",
idUsuario)
claseListaSimple.actualizarReservacion(idReservacion)
nuevoNodo = NodoLista(numeroTarjeta, totalGastado)
claseArbolAvl.agregarListaAVL(nuevoNodo)
return "Reservacion Exitosa"
except:
return "Error en el Servidor"
def crear(self, fila, columna):
self.m = NodoMatriz(0, 0, 0)
self.m.sigfil = self.m
self.m.sigcol = self.m
i = 1
q = self.m
while i <= fila:
nuevoNodo = NodoMatriz(0, i, 0)
q.sigfil = nuevoNodo
nuevoNodo.sigcol = nuevoNodo
q = nuevoNodo
i += 1
q.sigfil = self.m
i = 1
q = self.m
while i <= columna:
nuevoNodo = NodoMatriz(0, 0, i)
q.sigcol = nuevoNodo
nuevoNodo.sigfil = nuevoNodo
q = nuevoNodo
i += 1
q.sigcol = self.m
#print(claseHash.retornarMaxsize())
print(claseHash.eliminar(1))
print(claseHash.eliminar(9))
print(claseHash.eliminar(10))
claseHash.mostrar()
print(claseHash.tablaVacia())
elif num == "10":
anio = "2017"
numeroMes = "02"
dia = "14"
mes = claseMatriz.verMes(numeroMes)
claseMatriz.aumetarContador()
codigo = str(claseMatriz.obtenerContador())
nuevoNodo = NodoMatriz(mes, numeroMes, anio, dia, codigo)
if claseMatriz.existeReservacion(nuevoNodo) == False:
claseMatriz.agregarCabecerasMatriz(nuevoNodo)
if claseMatriz.necesitaProfundidad(nuevoNodo) == True:
claseMatriz.agregarProfundidad(nuevoNodo)
else:
claseMatriz.agregarMatriz(nuevoNodo)
elif num == "11":
anio = "2019"
numeroMes = "05"
dia = "3"
mes = claseMatriz.verMes(numeroMes)
def insertar(self, dominio, letra, correo):
cabecera = self.__listaCabecera.buscar(dominio)
if cabecera is None:
print("---creando cabecera " + dominio)
cabecera = self.__listaCabecera.insertar(dominio)
print("usando cabecera " + dominio)
lateral = self.__listaLateral.buscar(letra)
if lateral is None:
print("---creando lateral " + letra)
lateral = self.__listaLateral.insertar(letra)
print("usando lateral " + letra)
# buscamos si ya existe el primer nodo con la letra
nodo = self.obtenerNodo(dominio, letra)
if nodo is not None:
nodo.insertar(letra, dominio, correo)
return nodo
else:
nuevo = NodoMatriz()
nuevo.setLetra(letra)
nuevo.setDominio(dominio)
nuevo.setCabecera(cabecera)
nuevo.setLateral(lateral)
nuevo.insertar(letra, dominio, correo)
# si la cabecera aun no tiene el inicio del Matriz
# es porque esta vacio
if cabecera.getInicioMatriz() is None:
print("---lista cabecera vacia, creando nodo inicio y fin")
cabecera.setInicioMatriz(nuevo)
cabecera.setFinMatriz(nuevo)
else:
if letra < cabecera.getInicioMatriz().getLateral().getLetra():
print("insertarAlInicioY")
self.insertarAlInicioY(cabecera.getInicioMatriz(), nuevo)
cabecera.setInicioMatriz(nuevo)
elif letra > cabecera.getFinMatriz().getLateral().getLetra():
print("insertarAlFinalY")
self.insertarAlFinalY(cabecera.getFinMatriz(), nuevo)
cabecera.setFinMatriz(nuevo)
else:
print("insertarAlMedioY")
self.insertarAlMedioY(cabecera.getInicioMatriz(), nuevo)
# si la cabecera aun no tiene el inicio del Matriz
# es porque esta vacio
if lateral.getInicioMatriz() is None:
print("---lista lateral vacia, creando nodo inicio y fin")
lateral.setInicioMatriz(nuevo)
lateral.setFinMatriz(nuevo)
else:
iDominio = lateral.getInicioMatriz().getCabecera().getDominio()
fDominio = lateral.getFinMatriz().getCabecera().getDominio()
if (dominio < iDominio):
print("insertarAlInicioX")
self.insertarAlInicioX(lateral.getInicioMatriz(), nuevo)
lateral.setInicioMatriz(nuevo)
elif (dominio > fDominio):
print("insertarAlFinalX")
self.insertarAlFinalX(lateral.getFinMatriz(), nuevo)
lateral.setFinMatriz(nuevo)
else:
print("insertarAlMedioX")
self.insertarAlMedioX(lateral.getInicioMatriz(), nuevo)
return nuevo
def obtenerNodoPrevioDominio(
self, x, valor, letra
): #Este metodo recibe el nodo dominio, el nombre del correo, y la inicial del nombre
#Utilizo este metodo para bajar desde el dominio y verificar donde ingresar el nodo con el nombre del correo
temp = NodoMatriz(
) #Este nodo me servira para bajar partiendo desde el nodo dominio recibido
temp = x.abajo
nodo = NodoMatriz() #Este nodo contendra todos los valores del correo
nodo.valor = valor
nodo.dominio = x.valor
nodo.letra = letra
aux = None #este nodo me servira para devolver el nodo de valores cuando se haya ingresado (o sea que ya tenga sus apuntadores verticales)
bandera = 0
if temp is None: #Si el nodo abajo del dominio es none se agrega y se iguala a aux
x.abajo = nodo
x.abajo.arriba = x
aux = x.abajo
else:
while temp is not None: #uso este while para recorrer los correos que existen con el dominio recibido
if temp.letra == letra: #Si existe un nodo con la letra de mi nodo valor quiere decir que debo de enviarlo a atras
if temp.atras is None:
nodo.adelante = temp
nodo.adelante.atras = nodo
temp = temp.atras
else:
while temp.atras is not None:
temp = temp.atras
temp.atras = nodo
temp.atras.adelante = temp
bandera = 1
break #--------------------------
if ord(temp.letra[0]) > ord(
letra[0]
): #Averiguo si deberia meter mi nodo valores antes de cualquier otro
if temp == x:
x.abajo = nodo
x.abajo.arriba = x
aux = x.abajo
else:
temp.arriba.abajo = nodo
temp.arriba.abajo.arriba = temp.arriba
nodo.abajo = temp
temp.arriba = nodo
aux = temp.arriba
bandera = 1
break
temp = temp.abajo
if bandera == 1:
print("")
else: #Si no entre a ningun caso entonces lo agrego al final de todos los correos del dominio recibido
temp = x
while temp.abajo is not None:
temp = temp.abajo
temp.abajo = nodo
temp.abajo.arriba = temp
temp = temp.abajo
aux = temp
return aux
def insertarValor(self, nodomes, valor, fecha,
dia): #Este metodo recibe el nodo empresa,
#el nombre del empleado, y el depto al que pertenece [Valor = username]
#Utilizo este metodo para bajar desde la empresa y verificar donde ingresar el nodo con el nombre del empleado
temp = NodoMatriz(
) #Este nodo me servira para bajar partiendo desde el nodo empresa recibido
temp = nodomes.abajo
nodo = NodoMatriz(
) #Este nodo contendra todos los valores del empleado
nodo.valor = valor
nodo.mes = nodomes.valor
nodo.fecha = fecha
nodo.dia = dia
aux = None #este nodo me servira para devolver el nodo de valores cuando
# se haya ingresado (o sea que ya tenga sus apuntadores verticales)
bandera = 0
if temp is None: #Si el nodo abajo del dominio es none se agrega y se iguala a aux
nodomes.abajo = nodo
nodomes.abajo.arriba = nodomes
aux = nodomes.abajo
else:
while temp is not None: #uso este while para recorrer los empleados que existen en la empresa recibida
tipofecha = [temp.fecha, fecha]
tipofecha.sort()
if temp.fecha == fecha: #Si existe un nodo con el departamento de mi nodo valor
#quiere decir que debo de enviarlo a atras
if temp.atras is None: #Si
nodo.adelante = temp
nodo.adelante.atras = nodo
temp = temp.atras
else:
while temp.atras is not None:
temp = temp.atras
temp.atras = nodo
temp.atras.adelante = temp
bandera = 1
break #--------------------------
if (
tipofecha.index(temp.fecha) == 1
): #Averiguo si deberia meter mi nodo valores antes de cualquier otro
if temp == nodomes:
nodomes.abajo = nodo
nodomes.abajo.arriba = nodomes
aux = nodomes.abajo
else:
temp.arriba.abajo = nodo
temp.arriba.abajo.arriba = temp.arriba
nodo.abajo = temp
temp.arriba = nodo
aux = temp.arriba
bandera = 1
break
temp = temp.abajo
if bandera == 1:
print("")
else: #Si no entre a ningun caso entonces lo agrego al final de todos los correos del dominio recibido
temp = nodomes
while temp.abajo is not None:
temp = temp.abajo
temp.abajo = nodo
temp.abajo.arriba = temp
temp = temp.abajo
aux = temp
return aux
def agregarInicioMes(self, nuevoNodo):
nuevoNodo1 = NodoMatriz(str(nuevoNodo.mes), str(nuevoNodo.numeroMes),
"")
nuevoNodo1.derecha = self.inicioMes
self.inicioMes.izquierda = nuevoNodo1
self.inicioMes = nuevoNodo1
def agregarCabecerasMatriz(self, nuevoNodo):
if self.existeMes(nuevoNodo) == False:
if self.inicioMes == None:
nuevoNodo1 = NodoMatriz(str(nuevoNodo.mes),
str(nuevoNodo.numeroMes), "")
self.inicioMes = nuevoNodo1
elif self.inicioMes != None:
temp1 = self.inicioMes
#departamentoNuevo = nuevoNodo.departamento
#caracterNuevo = departamentoNuevo[0]
numeroMes = nuevoNodo.numeroMes #caracterNuevoASCII = ord(caracterNuevo)
while temp1 != None:
#departamento1 = temp1.departamento
#caracter1 = departamento1[0]
numeroMes1 = temp1.numeroMes #caracter1ASCII = ord(caracter1)
if temp1.derecha != None:
temp2 = temp1.derecha
#departamento2 = temp2.departamento
#caracter2 = departamento2[0]
numeroMes2 = temp2.numeroMes #caracter2ASCII = ord(caracter2)
if numeroMes < numeroMes1:
self.agregarInicioMes(nuevoNodo)
break
elif numeroMes > numeroMes1:
if numeroMes < numeroMes2:
self.agregarMedioMes(temp1, nuevoNodo, temp2)
break
#elif numeroMes > numeroMes1:
elif numeroMes == numeroMes1:
#self.agregarMedioMes(temp1, nuevoNodo, temp2) **************************************
break
else:
if numeroMes < numeroMes1:
self.agregarInicioMes(nuevoNodo)
break
else:
self.agregarFinMes(nuevoNodo)
break
temp1 = temp1.derecha
if self.existeAnio(nuevoNodo) == False:
if self.inicioAnio == None:
nuevoNodo1 = NodoMatriz("", "", str(nuevoNodo.anio))
self.inicioAnio = nuevoNodo1
elif self.inicioAnio != None:
temp1 = self.inicioAnio
#empresaNuevo = nuevoNodo.empresa
#caracterNuevo = empresaNuevo[0]
numeroAnio = nuevoNodo.anio #caracterNuevoASCII = ord(caracterNuevo)
while temp1 != None:
#empresa1 = temp1.empresa
#caracter1 = empresa1[0]
numeroAnio1 = temp1.anio #caracter1ASCII = ord(caracter1)
if temp1.abajo != None:
temp2 = temp1.abajo
#empresa2 = temp2.empresa
#caracter2 = empresa2[0]
numeroAnio2 = temp2.anio #caracter2ASCII = ord(caracter2)
if numeroAnio < numeroAnio1:
self.agregarInicioAnio(nuevoNodo)
break
elif numeroAnio > numeroAnio1:
if numeroAnio < numeroAnio2:
self.agregarMedioAnio(temp1, nuevoNodo, temp2)
break
elif numeroAnio == numeroAnio1:
#self.agregarMedioAnio(temp1, nuevoNodo, temp2) *************************************
break
else:
if numeroAnio < numeroAnio1:
self.agregarInicioAnio(nuevoNodo)
break
else:
self.agregarFinAnio(nuevoNodo)
break
temp1 = temp1.abajo
def agregarMedioAnio(self, nodo1, nuevoNodo, nodo2):
nuevoNodo1 = NodoMatriz("", "", str(nuevoNodo.anio))
nodo1.abajo = nuevoNodo1
nuevoNodo1.arriba = nodo1
nuevoNodo1.abajo = nodo2
nodo2.arriba = nuevoNodo1
def agregarInicioAnio(self, nuevoNodo):
nuevoNodo1 = NodoMatriz("", "", str(nuevoNodo.anio))
nuevoNodo1.abajo = self.inicioAnio
self.inicioAnio.arriba = nuevoNodo1
self.inicioAnio = nuevoNodo1
def insertarValor(
self, x, valor, departamento, username, password, nombreCompleto
): #Este metodo recibe el nodo empresa, el nombre del empleado, y el depto al que pertenece [Valor = username]
#Utilizo este metodo para bajar desde la empresa y verificar donde ingresar el nodo con el nombre del empleado
temp = NodoMatriz(
) #Este nodo me servira para bajar partiendo desde el nodo empresa recibido
temp = x.abajo
nodo = NodoMatriz(
) #Este nodo contendra todos los valores del empleado
nodo.valor = valor
nodo.empresa = x.valor
nodo.departamento = departamento
nodo.nombreUsuario = username
nodo.password = password
nodo.nombreCompleto = nombreCompleto
aux = None #este nodo me servira para devolver el nodo de valores cuando se haya ingresado (o sea que ya tenga sus apuntadores verticales)
bandera = 0
if temp is None: #Si el nodo abajo del dominio es none se agrega y se iguala a aux
x.abajo = nodo
x.abajo.arriba = x
aux = x.abajo
else:
while temp is not None: #uso este while para recorrer los empleados que existen en la empresa recibida
nombresDepartamentos = [temp.departamento, departamento]
nombresDepartamentos.sort()
if temp.departamento == departamento: #Si existe un nodo con el departamento de mi nodo valor quiere decir que debo de enviarlo a atras
if temp.atras is None: #Si
nodo.adelante = temp
nodo.adelante.atras = nodo
temp = temp.atras
else:
while temp.atras is not None:
temp = temp.atras
temp.atras = nodo
temp.atras.adelante = temp
bandera = 1
break #--------------------------
if (
nombresDepartamentos.index(temp.departamento) == 1
): #Averiguo si deberia meter mi nodo valores antes de cualquier otro
if temp == x:
x.abajo = nodo
x.abajo.arriba = x
aux = x.abajo
else:
temp.arriba.abajo = nodo
temp.arriba.abajo.arriba = temp.arriba
nodo.abajo = temp
temp.arriba = nodo
aux = temp.arriba
bandera = 1
break
temp = temp.abajo
if bandera == 1:
print("")
else: #Si no entre a ningun caso entonces lo agrego al final de todos los correos del dominio recibido
temp = x
while temp.abajo is not None:
temp = temp.abajo
temp.abajo = nodo
temp.abajo.arriba = temp
temp = temp.abajo
aux = temp
return aux