Generate a Connected Graph java

Question

I want to write a function, which is given a set of vertices and then develops an edge between 2 vertices and repeats this until the graph becomes a connected graph). How can I tell when the graph has become connected?

Answer 1

This would be a basic idea: Every time you add a new edge, you run BFS or DFS to check the connectivity. This solution is can be further optimized.

import java.util.Deque;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Random;
import java.util.Set;

import org.jgrapht.graph.DefaultEdge;
import org.jgrapht.graph.SimpleGraph;

public class Main {

public static boolean isConnected(SimpleGraph<Integer, DefaultEdge> graph) {
    Set<Integer> vertexSet = graph.vertexSet();
    if(vertexSet.size()==0) {
        //graph is connected by definition
        return true;
    }

    if(vertexSet.size()-1>graph.edgeSet().size()) {
        //not enough edges, must be disconnected
        return false;
    }

    Set<Integer> traversed = new HashSet<>();
    Deque<DefaultEdge> toTraverse = new LinkedList<DefaultEdge>();

    //pick one random element to start search
    Integer startVertex = vertexSet.iterator().next();

    traversed.add(startVertex);
    graph.edgesOf(startVertex).forEach(x->toTraverse.addLast(x));
    while(traversed.size()!=vertexSet.size() && toTraverse.size()!=0) {
        DefaultEdge currentEdge = toTraverse.pollFirst();
        Integer src = graph.getEdgeSource(currentEdge);
        Integer dst = graph.getEdgeSource(currentEdge);

        //it can be at most one new vertex
        Integer targetVertex = traversed.contains(src)?dst:src;
        if(!traversed.contains(targetVertex)) {
            traversed.add(targetVertex);
            //BFS
            graph.edgesOf(targetVertex).forEach(x->toTraverse.addLast(x));

            //DFS
            //graph.edgesOf(targetVertex).forEach(x->toTraverse.addFirst(x));
        }
    }

    if(traversed.size()==vertexSet.size()) {
        return true;
    }else {
        return false;
    }
}

public static SimpleGraph<Integer, DefaultEdge> buildGraph(int numberOfVertices) {
    SimpleGraph<Integer, DefaultEdge> g =
            new SimpleGraph<Integer, DefaultEdge>(DefaultEdge.class);
    for(int i = 0; i < numberOfVertices; i++) {
        g.addVertex(i);
    }
    Random r = new Random();
    do {
        int a = r.nextInt(numberOfVertices);
        int b = r.nextInt(numberOfVertices);
        while(a == b) {
            b = r.nextInt(numberOfVertices);
        }
        g.addEdge(a, b);
    }while(!isConnected(g));
    return g;

}

public static void main(String[] args) {
    SimpleGraph<Integer, DefaultEdge> g = buildGraph(10);
    System.out.println("Number of edges");
    System.out.println(g.edgeSet().size());
    System.out.println("Edges:");
    for(DefaultEdge e: g.edgeSet()){
        String a = g.getEdgeSource(e).toString();
        String b = g.getEdgeTarget(e).toString();
        System.out.println(a+" "+b);
    }
}

}

For an arbitrary graph, checking connectivity requires at least O(V) (V - number of vertices, E - number of edges). BFS and DFS run in O(V+E). This might be fine if you want to create relatively small graphs. Here is a smarter idea how to do it. At the beginning you create V separate graphs. Now you want to add edge between A and B, you find the graph where A belongs and the other where B belongs. If those are two different graphs, merge them. Repeat this process until only one graph remains.