Alguém poderia me ajudar nessa atividade sobre busca em largura em um grafo?

import java.util.LinkedList;
import java.util.Queue;

/**
 *
 * @author David
 */
public class Graph {

    private int V;
    private LinkedList<Integer> adj[];

    Graph( int v ) {
        V = v;
        adj = new LinkedList[v];
        for ( int i = 0; i < v; ++i ) {
            adj[i] = new LinkedList();
        }
    }

    void addEdge( int v, int w ) {
        adj[v].add( w );
        adj[w].add( v );
    }

    void BFS( int s ) {

        boolean visited[] = new boolean[V];

        Queue<Integer> queue = new LinkedList<>();

        visited[s] = true;
        queue.add( s );

        while ( !queue.isEmpty() ) {

            s = queue.poll();
            System.out.println( s + " " );

            for ( int n : adj[s] ) {
                if ( !visited[n] ) {
                    visited[n] = true;
                    queue.add( n );
                }
            }
            
        }
    }

    public static void main( String args[] ) {
        
        Graph g = new Graph( 4 );

        g.addEdge( 0, 1 );
        g.addEdge( 0, 2 );
        g.addEdge( 1, 2 );
        g.addEdge( 2, 3 );

        System.out.println( "A seguir está a primeira travessia em largura " + "(starting from vertex 2)" );

        g.BFS( 2 );
        
    }
    
}

adj[0] = { 2, 1 }
adj[1] = { 2, 0 }
adj[2] = { 3, 1, 0 }
adj[3] = { 2 }

// início
visited = F | F | F | F  (F = false, T = true)
          0   1   2   3

queue = {}

// inserção da fonte na fila e marcação de visitado
visited = F | F | T | F
          0   1   2   3

queue = { 2 }

// a fila está vazia? não!
s = 2
queue = {}

adjacentes de 2:
    3: visitado? não!
       visited[3] = true;  =>  visited = F | F | T | T
       queue = { 3 }                     0   1   2   3
       
    1: visitado? não!
       visited[1] = true;  =>  visited = F | T | T | T
       queue = { 1, 3 }                  0   1   2   3
       
    0: visitado? não!
       visited[0] = true;  =>  visited = T | T | T | T
       queue = { 0, 1, 3 }               0   1   2   3

// perceba que no seu exemplo, todos os vértices
// já estão visitados e a árvore de busca em largura 
// gerada já está pronta (seu exemplo não a codifica, 
// se quiser eu complemento para vc.

// a ideia da busca em largura é obter essa árvore e
// os custos associados a quantidade de "pulos" que se
// da de um vértice a outro, sendo algo parecido com um
// algoritmo de menor caminho, mas sem pesos nas arestas

// continuando...
// a fila está vazia? não!
s = 3
queue = { 0, 1 }

adjacentes de 3:
    2: visitado? sim!

// a fila está vazia? não!
s = 1
queue = { 0 }

adjacentes de 1:
    2: visitado? sim!
    0: visitado? sim!
    
// a fila está vazia? não!
s = 0
queue = {}

adjacentes de 0:
    2: visitado? sim!
    1: visitado? sim!
    
// a fila está vazia? sim!