Example #1
0
 /**
  * 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;
 }
Example #2
0
 /**
  * 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;
 }
Example #3
0
  /**
   * 5) Colección de entidades que son sujeto en todos y cada uno de los almacenes.
   *
   * @param coleccionAlmacenes - almacenes a intersectar
   * @return Una lista enlazada de entidades que son sujeto en todos y cada uno de los almacenes
   */
  public static ListaEnlazada<String> entidadesSujetoEnTodos(Almacen[] coleccionAlmacenes) {
    ListaEnlazada<String> resultado = new ListaEnlazada<String>();
    int menor = 0, i, j, valor;
    boolean posibleSujetoComun;
    String sujeto;

    // Se busca el índice del almacén que tiene menor número de sujetos
    for (i = 0; i < coleccionAlmacenes.length; i++)
      if (coleccionAlmacenes[i].sujetos < coleccionAlmacenes[menor].sujetos) menor = i;

    for (i = 0; i < coleccionAlmacenes[menor].nodosSalientes.size(); i++) {
      // Recorrer todas las entidades del almacén
      if (!coleccionAlmacenes[menor].nodosSalientes.get(i).isEmpty()) {
        // En caso de ser un sujeto, se busca en el resto de los almacenes
        sujeto = coleccionAlmacenes[menor].listaSujetosObjetos.get(i);
        posibleSujetoComun = true;
        j = 0;
        while (j < coleccionAlmacenes.length && posibleSujetoComun) {
          valor = coleccionAlmacenes[j].arbolSujetosObjetos.obtenerValor(sujeto);
          if (valor == -1 || coleccionAlmacenes[j].nodosSalientes.get(valor).isEmpty()) {
            // No existe o no es sujeto en el almacén j -> se deja de buscar
            posibleSujetoComun = false;
          }
          j++;
        }

        if (posibleSujetoComun) {
          // Es sujeto en todos los almacenes
          resultado.insertLast(sujeto);
        }
      }
    }

    return resultado;
  }
Example #4
0
  /**
   * 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;
  }
Example #5
0
 /**
  * 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;
 }
Example #6
0
 // 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);
     }
   }
 }
Example #7
0
 // 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);
     }
   }
 }