refactor: deduplicate countComponents and bfsDistances into GraphUtils

Added GraphUtils.countComponents(Graph) — counts connected components
without allocating per-component Sets or sorting (just a visited set +
BFS counter). 4 callers were using findComponents(g).size() which built
the full component list, sorted it, then discarded everything except
the count.

Also replaced GraphPowerCalculator's private bfsDistances() with a
one-line delegate to GraphUtils.bfsDistances() — same BFS logic was
duplicated verbatim (~15 lines).

Files changed:
- GraphUtils.java: +countComponents()
- GraphPowerCalculator.java: -15 lines (delegate to GraphUtils)
- GraphResilienceAnalyzer.java: delegate to GraphUtils.countComponents
- GraphSparsificationAnalyzer.java: delegate to GraphUtils.countComponents
- FeedbackVertexSetAnalyzer.java: delegate to GraphUtils.countComponents
- TreeAnalyzer.java: delegate to GraphUtils.countComponents

Author: sauravbhattacharya001

Gvisual/src/gvisual/FeedbackVertexSetAnalyzer.java

@@ -213,7 +213,7 @@ public int cycleRank() {
     }
 
     private int countComponents() {
-        return GraphUtils.findComponents(graph).size();
+        return GraphUtils.countComponents(graph);
     }
 
     // ── Bounds ────────────────────────────────────────────────────

Gvisual/src/gvisual/GraphPowerCalculator.java

@@ -69,21 +69,7 @@ public Map<String, Map<String, Integer>> allPairsDistances() {
     }
 
     private Map<String, Integer> bfsDistances(String source) {
-        Map<String, Integer> dist = new LinkedHashMap<>();
-        Queue<String> queue = new ArrayDeque<>();
-        dist.put(source, 0);
-        queue.add(source);
-        while (!queue.isEmpty()) {
-            String current = queue.poll();
-            int d = dist.get(current);
-            for (String neighbor : graph.getNeighbors(current)) {
-                if (!dist.containsKey(neighbor)) {
-                    dist.put(neighbor, d + 1);
-                    queue.add(neighbor);
-                }
-            }
-        }
-        return dist;
+        return GraphUtils.bfsDistances(graph, source);
     }
 
     /**

Gvisual/src/gvisual/GraphResilienceAnalyzer.java

@@ -324,8 +324,7 @@ private int largestComponentSize(Graph<String, Edge> g) {
     }
 
     private int countComponents(Graph<String, Edge> g) {
-        if (g.getVertexCount() == 0) return 0;
-        return GraphUtils.findComponents(g).size();
+        return GraphUtils.countComponents(g);
     }
 
     private double globalEfficiency(Graph<String, Edge> g) {

Gvisual/src/gvisual/GraphSparsificationAnalyzer.java

@@ -271,7 +271,7 @@ public SparsificationQuality evaluateQuality(Graph<String, Edge> sparse) {
     }
 
     private int countComponents(Graph<String, Edge> g) {
-        return GraphUtils.findComponents(g).size();
+        return GraphUtils.countComponents(g);
     }
 
     private double degreeCorr(Graph<String, Edge> g1, Graph<String, Edge> g2) {

Gvisual/src/gvisual/GraphUtils.java

@@ -171,6 +171,41 @@ public static List<Set<String>> findComponents(
         return components;
     }
 
+    /**
+     * Counts the number of connected components without building or sorting
+     * the full component list.  Use this instead of
+     * {@code findComponents(graph).size()} when only the count is needed.
+     *
+     * @param graph the JUNG graph
+     * @return number of connected components
+     */
+    public static int countComponents(Graph<String, Edge> graph) {
+        Set<String> visited = new HashSet<String>();
+        int count = 0;
+        for (String vertex : graph.getVertices()) {
+            if (!visited.contains(vertex)) {
+                count++;
+                // Inline BFS to mark visited without building a component set
+                ArrayDeque<String> queue = new ArrayDeque<String>();
+                visited.add(vertex);
+                queue.add(vertex);
+                while (!queue.isEmpty()) {
+                    String current = queue.poll();
+                    Collection<Edge> incident = graph.getIncidentEdges(current);
+                    if (incident == null) continue;
+                    for (Edge e : incident) {
+                        String neighbor = getOtherEnd(e, current);
+                        if (neighbor != null && !visited.contains(neighbor)) {
+                            visited.add(neighbor);
+                            queue.add(neighbor);
+                        }
+                    }
+                }
+            }
+        }
+        return count;
+    }
+
     /**
      * Finds the largest connected component.
      *

Gvisual/src/gvisual/TreeAnalyzer.java

@@ -776,7 +776,7 @@ private void requireTree() {
     }
 
     private int countComponents() {
-        return GraphUtils.findComponents(graph).size();
+        return GraphUtils.countComponents(graph);
     }
 
     private void computeSubtreeSizes(String root, Map<String, Integer> subtreeSize,