Пример #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;
 }
Пример #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;
 }
Пример #3
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;
  }
Пример #4
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;
 }
Пример #5
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);
     }
   }
 }
Пример #6
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);
     }
   }
 }
Пример #7
0
 /**
  * 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;
   }
 }
Пример #8
0
 /**
  * 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;
 }
Пример #9
0
  /**
   * Constructora Carga las sentencias en el almacén desde el fichero especificado.
   *
   * @param nombreDeArchivo de texto desde el que leer las entidades
   */
  private Almacen(String nombreDeArchivo) throws IOException {
    // Inicializa los atributos de la clase
    nodosEntrantes = new ListaArray<ListaArray<Arista>>();
    nodosSalientes = new ListaArray<ListaArray<Arista>>();
    sujetos = objetos = propiedades = sentencias = 0;
    arbolSujetosObjetos = new Trie();
    arbolPropiedades = new Trie();
    listaSujetosObjetos = new ListaArray<String>();
    listaPropiedades = new ListaArray<String>();
    // Variables auxiliares
    int tempArista;
    Arista a;

    // Lee las sentencias desde el fichero y las añade al trie y a la lista de nodos del grafo
    Fichero.abrir(nombreDeArchivo, false, false);
    String sentencia, sujeto, propiedad, objeto;
    int idSujeto, idPropiedad, idObjeto;
    StringTokenizer tokenizador;
    sentencia = Fichero.leerSentencia();
    while (sentencia != null) {
      tokenizador = new StringTokenizer(sentencia);
      sujeto = tokenizador.nextToken();
      propiedad = tokenizador.nextToken();
      objeto = tokenizador.nextToken();
      sentencias++;

      // Insertar sujeto en el trie
      idSujeto = arbolSujetosObjetos.insertar(sujeto, sujetos + objetos);
      if (idSujeto == sujetos + objetos) {
        // Agregar al array de int -> String
        listaSujetosObjetos.insertLast(sujeto);
        // Añadir su hueco en las listas de adyacencia
        nodosEntrantes.insertLast(new ListaArray<Arista>());
        nodosSalientes.insertLast(new ListaArray<Arista>());
        // Incrementar contador
        sujetos++;
      }
      // Insertar propiedad en el trie
      idPropiedad = arbolPropiedades.insertar(propiedad, propiedades);
      if (idPropiedad == propiedades) {
        // Agregar al array de int -> String
        listaPropiedades.insertLast(propiedad);
        // En caso de ser una propiedad especial, guardar su valor entero
        if (propiedad.equals(propiedadEs)) idPropiedadEs = idPropiedad;
        else if (propiedad.equals(propiedadSubClaseDe)) idPropiedadSubClaseDe = idPropiedad;
        else if (propiedad.equals(propiedadCursa)) idPropiedadCursa = idPropiedad;
        else if (propiedad.equals(propiedadEncargadoDe)) idPropiedadEncargadoDe = idPropiedad;
        else if (propiedad.equals(propiedadDepartamentoDe)) idPropiedadDepartamentoDe = idPropiedad;
        else if (propiedad.equals(propiedadTrabajaPara)) idPropiedadTrabajaPara = idPropiedad;
        // Incrementar contador
        propiedades++;
      }
      // Insertar objeto en el trie
      idObjeto = arbolSujetosObjetos.insertar(objeto, sujetos + objetos);
      if (idObjeto == sujetos + objetos) {
        // Agregar al array de int -> String
        listaSujetosObjetos.insertLast(objeto);
        // Añadir su hueco en las listas de adyacencia
        nodosEntrantes.insertLast(new ListaArray<Arista>());
        nodosSalientes.insertLast(new ListaArray<Arista>());
        // Incrementar contador
        objetos++;
      }

      // Inserta la arista en la primera lista de adyacencia, o añade una repetición
      tempArista = nodosSalientes.get(idSujeto).find(new Arista(idObjeto, idPropiedad));
      if (tempArista == -1)
        nodosSalientes.get(idSujeto).insertLast(new Arista(idObjeto, idPropiedad));
      else nodosSalientes.get(idSujeto).get(tempArista).repeticiones++;

      // Lee la siguiente sentencia
      sentencia = Fichero.leerSentencia();
    }

    Fichero.cerrar();

    // Crear la segunda lista de adyacencia a partir de la primera
    for (int i = 0; i < nodosSalientes.size(); i++) {
      for (int j = 0; j < nodosSalientes.get(i).size(); j++) {
        a = nodosSalientes.get(i).get(j);
        nodosEntrantes
            .get(a.verticeObjetivo)
            .insertLast(new Arista(i, a.propiedad, a.repeticiones));
      }
    }

    // Ordenar las aristas salientes de cada nodo
    nodosSalientesOrdenados = new ListaArray<ListaArray<Integer>>(nodosSalientes.size());
    for (int i = 0; i < nodosSalientes.size(); ++i)
      nodosSalientesOrdenados.set(i, nodosSalientes.get(i).sort());
  }