Salve, sono un po arrugginito in materia. Devo rappresentare un grafo diretto con lista di adiacenze ed ho la necessità di creare una classe vertice ed una classe arco.

Ora, girovagando in rete ho visto molte varianti, ma nessuna mi convince appieno.

Metto intanto le classi vertice ed arco che ho scritto:

Vertex
codice:
public class Vertex {
    
    /** nome del vertice */
    private String name;
    
    public Vertex(String n) {
        setName(n);
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }
    
    public boolean equals(Object o) {
        Vertex comp = (Vertex)o;
        return comp.getName().equals(this.getName());
    }
}
Edge
codice:
public class Edge {
    
    private Vertex source; // nodo sorgente
    private Vertex sink;   // nodo destinazione
    private int capacity;
    private int flow;
    
    public Edge(Vertex so, Vertex si, int c, int f) {
        setSource(so);
        setSink(si);
        setCapacity(c);
        setFlow(f);
    }


    public int getCapacity() {
        return capacity;
    }


    public void setCapacity(int capacity) {
        this.capacity = capacity;
    }


    public int getFlow() {
        return flow;
    }


    public void setFlow(int flow) {
        this.flow = flow;
    }


    public Vertex getSource() {
        return source;
    }


    public void setSource(Vertex source) {
        this.source = source;
    }


    public Vertex getSink() {
        return sink;
    }


    public void setSink(Vertex sink) {
        this.sink = sink;
    }
    
    public boolean equals(Object o) {
        Edge e = (Edge)o;
        return this.source.equals(e.getSource()) && this.sink.equals(e.getSink());
    }
}
Ora non so quali strutture dati utilizzare nella classe grafo. Lista delle adiacenze di solito utilizza una mappa, dove per ogni vertice è associata una lista dei vertici vicini, ma io necessito di tenere traccia anche degli archi.

Considerando che le operazioni che devo fare sono:

1) Aggiunta di un vertice
2) Aggiunta di un arco (evitando self-loop e multi-archi)
3) Numerose BFS

Cosa mi conviene utilizzare? Grazie per l'aiuto.

Ps: avevo pensato ad una semplice lista di tutti vertici ed una lista di tutti gli archi, ma mi pare uno spreco. Oppure due mappe:
Una che associa ad ogni vertice la lista di archi uscenti, ed una che associa ad ogni vertice una lista di archi entranti.