perf(GraphResilienceAnalyzer): single-pass BFS for component count + largest size

Added GraphUtils.countAndLargest() that returns both component count
and largest component size in one BFS traversal. Updated
GraphResilienceAnalyzer.captureStep() and simulateRandomAttack() to
use it instead of separate findLargestComponent() + countComponents()
calls — eliminates one full O(V+E) BFS per simulation step across
all three attack strategies (degree, betweenness, random).

Author: sauravbhattacharya001

Gvisual/src/gvisual/GraphResilienceAnalyzer.java

@@ -279,14 +279,16 @@ private List<ResilienceStep> simulateRandomAttack(int trials) {
             List<String> vertices = new ArrayList<>(copy.getVertices());
             Collections.shuffle(vertices, rng);
 
-            accum[0][0] += largestComponentSize(copy);
-            accum[0][1] += countComponents(copy);
+            int[] cl0 = GraphUtils.countAndLargest(copy);
+            accum[0][0] += cl0[1];
+            accum[0][1] += cl0[0];
             accum[0][2] += globalEfficiency(copy);
 
             for (int step = 0; step < vertices.size(); step++) {
                 copy.removeVertex(vertices.get(step));
-                accum[step + 1][0] += largestComponentSize(copy);
-                accum[step + 1][1] += countComponents(copy);
+                int[] cl = GraphUtils.countAndLargest(copy);
+                accum[step + 1][0] += cl[1];
+                accum[step + 1][1] += cl[0];
                 accum[step + 1][2] += globalEfficiency(copy);
             }
         }
@@ -307,26 +309,23 @@ private Graph<String, Edge> copyGraph() {
         return GraphUtils.copyGraph(graph);
     }
 
+    /**
+     * Captures a resilience step using a single BFS traversal to get both
+     * the component count and the largest component size, instead of the
+     * previous two separate full-graph BFS passes.
+     */
     private ResilienceStep captureStep(Graph<String, Edge> g, int originalSize,
                                         int step, String removedNode) {
+        int[] cl = GraphUtils.countAndLargest(g);
         return new ResilienceStep(
                 step,
                 g.getVertexCount(),
-                largestComponentSize(g),
-                countComponents(g),
+                cl[1],
+                cl[0],
                 globalEfficiency(g),
                 removedNode);
     }
 
-    private int largestComponentSize(Graph<String, Edge> g) {
-        if (g.getVertexCount() == 0) return 0;
-        return GraphUtils.findLargestComponent(g).size();
-    }
-
-    private int countComponents(Graph<String, Edge> g) {
-        return GraphUtils.countComponents(g);
-    }
-
     private double globalEfficiency(Graph<String, Edge> g) {
         return GraphUtils.globalEfficiency(g);
     }

Gvisual/src/gvisual/GraphUtils.java

@@ -171,6 +171,44 @@ public static List<Set<String>> findComponents(
         return components;
     }
 
+    /**
+     * Returns the component count and the size of the largest connected
+     * component in a single BFS traversal — avoids the two separate
+     * traversals of {@code countComponents} + {@code findLargestComponent}.
+     *
+     * @param graph the JUNG graph
+     * @return int[2]: [0] = component count, [1] = largest component size
+     */
+    public static int[] countAndLargest(Graph<String, Edge> graph) {
+        Set<String> visited = new HashSet<String>();
+        int count = 0;
+        int largest = 0;
+        for (String vertex : graph.getVertices()) {
+            if (!visited.contains(vertex)) {
+                count++;
+                int compSize = 0;
+                ArrayDeque<String> queue = new ArrayDeque<String>();
+                visited.add(vertex);
+                queue.add(vertex);
+                while (!queue.isEmpty()) {
+                    String current = queue.poll();
+                    compSize++;
+                    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);
+                        }
+                    }
+                }
+                if (compSize > largest) largest = compSize;
+            }
+        }
+        return new int[]{count, largest};
+    }
+
     /**
      * Counts the number of connected components without building or sorting
      * the full component list.  Use this instead of