/**
* 11) Colección de profesores distintos que trabajan para algún departamento de una universidad.
*
* @param universidad - universidad de la que buscar profesores que trabajan para algún
* departamento suyo
* @return una lista enlazada de las entidades que son profesores que trabajan en algún
* departamento del parámetro universidad
*/
public ListaEnlazada<String> profesoresDeUniversidad(String universidad) {
ListaEnlazada<String> resultado = new ListaEnlazada<String>();
int idUniversidad = arbolSujetosObjetos.obtenerValor(universidad);
if (idUniversidad != -1) {
Arista a;
int nodoDepartamento;
boolean recorridos[] = new boolean[sujetos + objetos];
for (int i = 0; i < sujetos + objetos; ++i) recorridos[i] = false;
// Búsqueda las aristas entrantes de idUniversidad con peso 'departamentoDe'
for (int i = 0; i < nodosEntrantes.get(idUniversidad).size(); i++) {
a = nodosEntrantes.get(idUniversidad).get(i);
if (a.propiedad == idPropiedadDepartamentoDe && !recorridos[a.verticeObjetivo]) {
nodoDepartamento = a.verticeObjetivo;
recorridos[nodoDepartamento] = true;
// El nodo es un departamento, buscar las aristas entrantes con peso 'trabajaPara'
for (int j = 0; j < nodosEntrantes.get(nodoDepartamento).size(); j++) {
a = nodosEntrantes.get(nodoDepartamento).get(j);
if (a.propiedad == idPropiedadTrabajaPara && !recorridos[a.verticeObjetivo]) {
recorridos[a.verticeObjetivo] = true;
resultado.insertLast(listaSujetosObjetos.get(a.verticeObjetivo));
}
}
}
}
}
return resultado;
}
/**
* 10) Colección de estudiantes distintos que cursan alguna asignatura de la que es encargado un
* determinado profesor.
*
* @param profesor - profesor encargado de las asignaturas de las que se buscan los estudiantes
* @return una lista enlazada de las entidades que son estudiantes de asignaturas que imparte el
* parámetro profesor
*/
public ListaEnlazada<String> estudiantesDelProfesor(String profesor) {
ListaEnlazada<String> resultado = new ListaEnlazada<String>();
int idProfesor = arbolSujetosObjetos.obtenerValor(profesor);
if (idProfesor != -1) {
Arista a;
int nodoAsignatura;
boolean recorridos[] = new boolean[sujetos + objetos];
for (int i = 0; i < sujetos + objetos; ++i) recorridos[i] = false;
// Búsqueda las aristas salientes de idProfesor con peso 'encargadoDe'
for (int i = 0; i < nodosSalientes.get(idProfesor).size(); ++i) {
a = nodosSalientes.get(idProfesor).get(i);
if (a.propiedad == idPropiedadEncargadoDe && !recorridos[a.verticeObjetivo]) {
nodoAsignatura = a.verticeObjetivo;
recorridos[nodoAsignatura] = true;
// El nodo es una asignatura, buscar las aristas entrantes con peso 'cursa'
for (int j = 0; j < nodosEntrantes.get(nodoAsignatura).size(); ++j) {
a = nodosEntrantes.get(nodoAsignatura).get(j);
if (a.propiedad == idPropiedadCursa && !recorridos[a.verticeObjetivo]) {
recorridos[a.verticeObjetivo] = true;
resultado.insertLast(listaSujetosObjetos.get(a.verticeObjetivo));
}
}
}
}
}
return resultado;
}
/**
* 4) Colección de entidades distintas que son sujeto de alguna sentencia y también son objeto de
* alguna sentencia del almacén.
*
* @return Una lista enlazada de strings sin repeticiones que son sujeto y a la vez objeto en el
* almacén
*/
public ListaEnlazada<String> entidadesSujetoObjeto() {
ListaEnlazada<String> coleccionEntidades = new ListaEnlazada<String>();
for (int i = 0; i < nodosSalientes.size(); i++)
if (!nodosSalientes.get(i).isEmpty() && !nodosEntrantes.get(i).isEmpty())
coleccionEntidades.insertLast(listaSujetosObjetos.get(i));
return coleccionEntidades;
}
/**
* 2) Colección de sentencias distintas del almacén que tienen un sujeto determinado.
*
* @param sujeto - sujeto cuyas sentencias han de devolverse
* @return Una lista enlazada de sentencias sin repeticiones que tienen Sujeto como sujeto
*/
public ListaEnlazada<String> sentenciasDistintasPorSujeto(String sujeto) {
ListaEnlazada<String> coleccionSentencias = new ListaEnlazada<String>();
int index = arbolSujetosObjetos.obtenerValor(sujeto);
if (index != -1) {
// Si el sujeto no existe, devuelve una lista vacía
Arista prov;
for (int i = 0; i < nodosSalientes.get(index).size(); ++i) {
prov = nodosSalientes.get(index).get(i);
coleccionSentencias.insertLast(
listaSujetosObjetos.get(index)
+ " "
+ listaPropiedades.get(prov.propiedad)
+ " "
+ listaSujetosObjetos.get(prov.verticeObjetivo)
+ " .");
}
}
return coleccionSentencias;
}
// Búsqueda en profundidad desde "nodo" recorriendo solo las aristas de peso "propiedad"
// Los nodos que se recorren se guardan en "resultado"
private void DFS(int nodo, int propiedad, boolean[] recorridos, ListaEnlazada<String> resultado) {
Arista a;
for (int i = 0; i < nodosSalientes.get(nodo).size(); ++i) {
a = nodosSalientes.get(nodo).get(i);
if (a.propiedad == propiedad && !recorridos[a.verticeObjetivo]) {
recorridos[a.verticeObjetivo] = true;
resultado.insertLast(listaSujetosObjetos.get(a.verticeObjetivo));
DFS(a.verticeObjetivo, idPropiedadSubClaseDe, recorridos, resultado);
}
}
}
/**
* 6) Colección ordenada de todas las sentencias que aparecen en el almacén.
*
* @return Un array con las sentencias del almacén según el orden descrito en el enunciado
*/
public ListaArray<String> sentenciasOrdenadas() {
ListaArray<Integer> valores = arbolSujetosObjetos.recorrerEnProfundidad();
ListaArray<String> sentenciasEnOrden = new ListaArray<String>(sentencias);
int nodo;
Arista arista;
for (int i = 0; i < valores.size(); ++i) {
nodo = valores.get(i);
for (int j = 0; j < nodosSalientesOrdenados.get(nodo).size(); ++j) {
arista = nodosSalientes.get(nodo).get(nodosSalientesOrdenados.get(nodo).get(j));
for (int k = 0; k < arista.repeticiones; ++k)
sentenciasEnOrden.insertLast(
listaSujetosObjetos.get(nodo)
+ " "
+ listaPropiedades.get(arista.propiedad)
+ " "
+ listaSujetosObjetos.get(arista.verticeObjetivo)
+ " .");
}
}
return sentenciasEnOrden;
}
// Búsqueda en profundidad hacia atrás desde "nodo", recorriendo por nodosEntrantes
// Se lanza la búsqueda otra vez si el peso de la arista es 'subClaseDe', o se añade
// el nodo al resultado si el peso es 'es'
private void DFSinversa(int nodo, boolean[] recorridos, ListaEnlazada<String> resultado) {
Arista a;
for (int i = 0; i < nodosEntrantes.get(nodo).size(); ++i) {
a = nodosEntrantes.get(nodo).get(i);
if (a.propiedad == idPropiedadEs && !recorridos[a.verticeObjetivo]) {
recorridos[a.verticeObjetivo] = true;
resultado.insertLast(listaSujetosObjetos.get(a.verticeObjetivo));
} else if (a.propiedad == idPropiedadSubClaseDe && !recorridos[a.verticeObjetivo]) {
recorridos[a.verticeObjetivo] = true;
DFSinversa(a.verticeObjetivo, recorridos, resultado);
}
}
}
/**
* 9b) Descargar las sentencias de un almacén en un archivo de texto de nuestro directorio.
*
* @param nombreDeArchivo - fichero en el que se van a escribir las sentencias del almacén
*/
public void descargar(String nombreDeArchivo) {
try {
Arista arista;
Fichero.abrir(nombreDeArchivo, true, false);
for (int i = 0; i < nodosSalientes.size(); ++i) {
for (int j = 0; j < nodosSalientes.get(i).size(); ++j) {
arista = nodosSalientes.get(i).get(j);
for (int k = 0; k < arista.repeticiones; ++k)
Fichero.escribirSentencia(
listaSujetosObjetos.get(i)
+ " "
+ listaPropiedades.get(arista.propiedad)
+ " "
+ listaSujetosObjetos.get(arista.verticeObjetivo)
+ " .");
}
}
Fichero.cerrar();
} catch (IOException e) {
System.err.println("Error: Imposible acceder al fichero especificado.");
return;
}
}
