refactor(graph-utils): extract subset-aware IndexedGraph ctor; dedupe in WienerIndexCalculator

WienerIndexCalculator carried its own private `buildAdjacency(n, idxMap)`
helper that materialised int[][] adjacency over a single component using
exactly the same `List<Integer>[] -> int[][]` pattern already in use by
NodeCentralityAnalyzer, RandomWalkAnalyzer, GraphIsomorphismChecker, and
GraphUtils.IndexedGraph itself. The duplication was an attractor for
bugs (any future change to the adjacency representation has to be made
in N places) and obscured the fact that WienerIndexCalculator's "build
indexed adjacency over the largest component" step is just an instance
of the general "indexed view restricted to a vertex subset" operation.

Changes:
* GraphUtils.IndexedGraph: add a second constructor that takes a
  Collection<String> vertex subset and only includes edges with both
  endpoints in the subset. Vertex order is preserved from the
  collection's iteration order so callers can rely on stable integer
  indices (matches what WienerIndexCalculator was doing manually).
* WienerIndexCalculator: replace the local `buildAdjacency` helper +
  manual index map with a single `new GraphUtils.IndexedGraph(graph,
  component)` call. Net deletion: ~25 lines.

No behaviour change. Verified with mvn -q -DskipTests compile (exit 0)
and a smoke test asserting Wiener(P5)=20, Wiener(K4)=6, Wiener(empty)=0
all match pre-refactor values.

Author: sauravbhattacharya001

Gvisual/src/gvisual/GraphUtils.java

@@ -560,6 +560,48 @@ public IndexedGraph(Graph<String, Edge> graph) {
                 }
             }
         }
+
+        /**
+         * Builds an indexed representation restricted to a vertex subset.
+         * Only edges with both endpoints in {@code vertices} are included,
+         * and the vertex ordering is taken from {@code vertices}'s iteration
+         * order so callers can predict integer indices.
+         *
+         * <p>Useful for analyzers that operate on a single component (e.g.
+         * {@link WienerIndexCalculator}) without needing to allocate their
+         * own private adjacency representation.</p>
+         *
+         * @param graph    the source graph
+         * @param vertices the vertices to include; iteration order defines indices
+         */
+        public IndexedGraph(Graph<String, Edge> graph, Collection<String> vertices) {
+            vertexList = new ArrayList<String>(vertices);
+            n = vertexList.size();
+            vertexIndex = new HashMap<String, Integer>(n * 2);
+            for (int i = 0; i < n; i++) {
+                vertexIndex.put(vertexList.get(i), i);
+            }
+
+            @SuppressWarnings("unchecked")
+            List<Integer>[] tmp = new List[n];
+            for (int i = 0; i < n; i++) tmp[i] = new ArrayList<Integer>();
+            for (Edge e : graph.getEdges()) {
+                Integer ui = vertexIndex.get(e.getVertex1());
+                Integer vi = vertexIndex.get(e.getVertex2());
+                if (ui != null && vi != null && !ui.equals(vi)) {
+                    tmp[ui].add(vi);
+                    tmp[vi].add(ui);
+                }
+            }
+            adjLists = new int[n][];
+            for (int i = 0; i < n; i++) {
+                List<Integer> nb = tmp[i];
+                adjLists[i] = new int[nb.size()];
+                for (int j = 0; j < nb.size(); j++) {
+                    adjLists[i][j] = nb.get(j);
+                }
+            }
+        }
     }
 
     // ── Betweenness Centrality (array-based Brandes) ──────────────────

Gvisual/src/gvisual/WienerIndexCalculator.java

@@ -76,13 +76,13 @@ public void compute() {
 
         pairCount = (long) componentSize * (componentSize - 1) / 2;
 
-        // Build index and adjacency arrays
-        List<String> vertices = new ArrayList<String>(component);
-        int n = vertices.size();
-        Map<String, Integer> idxMap = new HashMap<String, Integer>(n * 2);
-        for (int i = 0; i < n; i++) idxMap.put(vertices.get(i), i);
-
-        int[][] adj = buildAdjacency(n, idxMap);
+        // Build indexed adjacency over the largest component.
+        // Delegates to GraphUtils.IndexedGraph to avoid duplicating the
+        // List<Integer>[] -> int[][] build pattern (also used by
+        // NodeCentralityAnalyzer, RandomWalkAnalyzer, etc.).
+        GraphUtils.IndexedGraph ig = new GraphUtils.IndexedGraph(graph, component);
+        int n = ig.n;
+        int[][] adj = ig.adjLists;
 
         // Reusable BFS structures
         int[] dist = new int[n];
@@ -180,27 +180,6 @@ public String getSummary() {
 
     // --- Private helpers ---
 
-    private int[][] buildAdjacency(int n, Map<String, Integer> idxMap) {
-        @SuppressWarnings("unchecked")
-        List<Integer>[] tmp = new List[n];
-        for (int i = 0; i < n; i++) tmp[i] = new ArrayList<Integer>();
-        for (Edge e : graph.getEdges()) {
-            Integer ui = idxMap.get(e.getVertex1());
-            Integer vi = idxMap.get(e.getVertex2());
-            if (ui != null && vi != null && !ui.equals(vi)) {
-                tmp[ui].add(vi);
-                tmp[vi].add(ui);
-            }
-        }
-        int[][] adj = new int[n][];
-        for (int i = 0; i < n; i++) {
-            List<Integer> nb = tmp[i];
-            adj[i] = new int[nb.size()];
-            for (int j = 0; j < nb.size(); j++) adj[i][j] = nb.get(j);
-        }
-        return adj;
-    }
-
     private void ensureComputed() {
         if (!computed) {
             throw new IllegalStateException("Call compute() before querying results");