Class Vértice

Este código en Java define una clase llamada G_Vertice, que representa un vértice en un grafo. A continuación, se analiza cada parte del código y se proporciona una explicación detallada:

import java.util.Objects
public class G_Vertice

private String etiqueta;

// Constructor de la clase, que recibe una etiqueta para el vértice.
public G_Vertice(String etiqueta) {
    this.etiqueta = etiqueta;
}

// Método para obtener la etiqueta del vértice.
public String getEtiqueta() {
    return etiqueta;
}

// Método que se sobrescribe para comprobar si el objeto actual es igual al objeto pasado como argumento.
@Override
public boolean equals(Object obj) {
    if (this == obj) { // Si el objeto es el mismo, devuelve true.
        return true;
    }
    if (obj == null || getClass() != obj.getClass()) { // Si el objeto pasado es nulo o no es de la misma clase, devuelve false.
        return false;
    }
    // Convierte el objeto pasado como argumento a la clase G_Vertice para comparar sus etiquetas.
    G_Vertice vertice = (G_Vertice) obj;
    return Objects.equals(etiqueta, vertice.etiqueta); // Compara las etiquetas de los vértices y devuelve true si son iguales, false en caso contrario.
}

// Método que se sobrescribe para devolver un valor de código hash basado en la etiqueta del vértice.
@Override
public int hashCode() {
    return Objects.hash(etiqueta); // Devuelve el código hash de la etiqueta del vértice.
}

Class Grafo

Implementa un grafo no dirigido utilizando un mapa para almacenar las relaciones entre vértices (docentes y estudiantes). Proporciona métodos para agregar vértices, establecer relaciones entre ellos, obtener listas de vértices y relaciones, y eliminar vértices y relaciones.

public class G_Grafo {
    private Map<G_Vertice, List<G_Vertice>> grafo;
    private Map<G_Vertice, List<G_Vertice>> relaciones;

    // Constructor de la clase, inicializa dos mapas para almacenar el grafo y las relaciones.
    public G_Grafo() {
        grafo = new HashMap<>();
        relaciones = new HashMap<>();
    }

    // Método para agregar un nuevo vértice al grafo si aún no existe en el mapa de relaciones.
    public void agregarVertice(G_Vertice vertice) {
        if (!relaciones.containsKey(vertice)) {
            relaciones.put(vertice, new ArrayList<>());
        }
    }

    // Método para establecer una relación bidireccional entre dos vértices en el grafo.
    public void agregarRelacion(G_Vertice vertice1, G_Vertice vertice2) {
        relaciones.get(vertice1).add(vertice2);
        relaciones.get(vertice2).add(vertice1);
    }

    // Método para obtener una lista de todos los vértices presentes en el grafo.
    public List<G_Vertice> obtenerVertices() {
        return new ArrayList<>(relaciones.keySet());
    }

    // Método para obtener una copia del mapa de relaciones del grafo.
    public Map<G_Vertice, List<G_Vertice>> obtenerRelaciones() {
        return new HashMap<>(relaciones);
    }

    // Método para agregar una arista al grafo, conectando dos vértices mediante la arista.
    public void agregarArista(G_Arista arista) {
        G_Vertice vertice1 = arista.getVertice1();
        G_Vertice vertice2 = arista.getVertice2();

        // Lanza una excepción si al menos uno de los vértices no existe en el grafo.
        if (!relaciones.containsKey(vertice1) || !relaciones.containsKey(vertice2)) {
            throw new IllegalArgumentException("Al menos uno de los vértices no existe en el grafo.");
        }

        // Agrega los vértices a la lista de adyacencia del otro si aún no están conectados.
        if (!relaciones.get(vertice1).contains(vertice2)) {
            relaciones.get(vertice1).add(vertice2);
            relaciones.get(vertice2).add(vertice1);
        }
    }

    // Método para eliminar un vértice y sus relaciones asociadas del grafo.
    public void eliminarVertice(G_Vertice vertice) {
        relaciones.remove(vertice);
        for (List<G_Vertice> adyacentes : relaciones.values()) {
            adyacentes.remove(vertice);
        }
    }

    // Método para eliminar una arista del grafo, rompiendo la relación entre los dos vértices que conecta.
    public void eliminarArista(G_Arista arista) {
        G_Vertice vertice1 = arista.getVertice1();
        G_Vertice vertice2 = arista.getVertice2();

        // Lanza una excepción si al menos uno de los vértices no existe en el grafo.
        if (!grafo.containsKey(vertice1) || !grafo.containsKey(vertice2)) {
            throw new IllegalArgumentException("Al menos uno de los vértices no existe en el grafo.");
        }

        grafo.get(vertice1).remove(vertice2);
        grafo.get(vertice2).remove(vertice1);
    }

    // Método para obtener una lista de todas las aristas presentes en el grafo (relaciones únicas entre vértices).
    public List<G_Arista> obtenerAristas() {
        List<G_Arista> aristas = new ArrayList<>();
        Set<G_Arista> aristasSet = new HashSet<>();

        // Recorre todas las relaciones del grafo y crea una arista para cada conexión única entre vértices.
        for (Map.Entry<G_Vertice, List<G_Vertice>> entry : relaciones.entrySet()) {
            G_Vertice vertice1 = entry.getKey();
            for (G_Vertice vertice2 : entry.getValue()) {
                G_Arista arista = new G_Arista(vertice1, vertice2);
                if (!aristasSet.contains(arista)) {
                    aristas.add(arista);
                    aristasSet.add(arista);
                }
            }
        }

        return aristas;
    }

    // Método para obtener una lista de vértices adyacentes al vértice dado en el grafo.
    public List<G_Vertice> obtenerAdyacentes(G_Vertice vertice) {
        // Lanza una excepción si el vértice no existe en el grafo.
        if (!grafo.containsKey(vertice)) {
            throw new IllegalArgumentException("El vértice no existe en el grafo.");
        }

        return new ArrayList<>(grafo.get(vertice));
    }
}