perf: optimize graph algorithms — single-pass stats, inline edge counting, efficient Dijkstra

CommunityDetector: compute internal edge metrics during BFS traversal
instead of a separate O(V*E) post-pass with per-community HashSet.
Edges are now counted as endpoints are discovered, using a single
global countedEdges set.

GraphStats: replace 3 separate vertex iterations (getMaxDegree,
getIsolatedNodeCount, getTopNodes) with a single-pass cache that
computes all vertex degree data once. getTopNodes now uses a min-heap
partial sort O(V log N) instead of full sort O(V log V).
getAverageWeight caches the total weight sum.

ShortestPathFinder: remove vertex-index indirection from Dijkstra —
eliminates O(V) vertex list construction and int-to-double-to-int
conversion on every PQ operation. areConnected() now uses early-
termination BFS instead of computing the full reachable set.

Author: sauravbhattacharya001

Gvisual/src/gvisual/CommunityDetector.java

@@ -191,6 +191,11 @@ public double getModularity(Graph<String, edge> graph) {
      * Each connected component is treated as a community. Communities are
      * ranked by size (largest first) and enriched with edge-type breakdowns.
      *
+     * <p>Edge metrics are computed during the BFS traversal itself: each edge
+     * is counted when the second endpoint is discovered (or when revisiting
+     * an already-visited member). This avoids a separate O(V*E) post-pass
+     * and eliminates the per-community HashSet of counted edges.</p>
+     *
      * @return detection result with communities and node mappings
      */
     public DetectionResult detect() {
@@ -199,7 +204,10 @@ public DetectionResult detect() {
         Map<String, Integer> nodeToCommunity = new HashMap<String, Integer>();
         int communityId = 0;
 
-        // Find connected components via BFS
+        // Track which edges have been counted globally to avoid double-counting
+        Set<edge> countedEdges = new HashSet<edge>();
+
+        // Find connected components via BFS, computing edge metrics inline
         for (String vertex : graph.getVertices()) {
             if (visited.contains(vertex)) continue;
 
@@ -215,27 +223,23 @@ public DetectionResult detect() {
 
                 for (edge e : graph.getIncidentEdges(current)) {
                     String neighbor = getOtherEnd(e, current);
-                    if (neighbor != null && !visited.contains(neighbor)) {
-                        visited.add(neighbor);
-                        queue.add(neighbor);
-                    }
-                }
-            }
+                    if (neighbor == null) continue;
 
-            // Compute internal edge metrics
-            Set<edge> counted = new HashSet<edge>();
-            for (String member : community.members) {
-                for (edge e : graph.getIncidentEdges(member)) {
-                    if (counted.contains(e)) continue;
-                    String other = getOtherEnd(e, member);
-                    if (other != null && community.members.contains(other)) {
-                        counted.add(e);
+                    // Count this edge if both endpoints are in this component
+                    // and we haven't counted it yet
+                    if (visited.contains(neighbor) && !countedEdges.contains(e)) {
+                        countedEdges.add(e);
                         community.internalEdges++;
                         community.totalWeight += e.getWeight();
                         String type = e.getType();
                         Integer count = community.edgeTypeCounts.get(type);
                         community.edgeTypeCounts.put(type, count == null ? 1 : count + 1);
                     }
+
+                    if (!visited.contains(neighbor)) {
+                        visited.add(neighbor);
+                        queue.add(neighbor);
+                    }
                 }
             }
 

Gvisual/src/gvisual/GraphStats.java

@@ -104,35 +104,79 @@ public double getAverageDegree() {
         return (2.0 * e) / v;
     }
 
-    /** Maximum degree among all visible nodes. */
-    public int getMaxDegree() {
-        int max = 0;
+    /**
+     * Cached per-vertex statistics computed once, reused by multiple methods.
+     * Avoids iterating all vertices 3+ separate times for max degree, isolated
+     * count, and top-N queries.
+     */
+    private int cachedMaxDegree = -1;
+    private int cachedIsolatedCount = -1;
+    private List<Map.Entry<String, Integer>> cachedDegreeEntries;
+
+    /**
+     * Computes and caches per-vertex degree data in a single pass.
+     * Subsequent calls to getMaxDegree(), getIsolatedNodeCount(), and
+     * getTopNodes() all reuse this cache instead of each iterating
+     * all vertices independently.
+     */
+    private void ensureVertexStatsComputed() {
+        if (cachedMaxDegree >= 0) return; // already computed
+
+        cachedMaxDegree = 0;
+        cachedIsolatedCount = 0;
+        cachedDegreeEntries = new ArrayList<Map.Entry<String, Integer>>();
+
         for (String node : graph.getVertices()) {
             int deg = graph.degree(node);
-            if (deg > max) max = deg;
+            cachedDegreeEntries.add(new AbstractMap.SimpleEntry<String, Integer>(node, deg));
+            if (deg > cachedMaxDegree) cachedMaxDegree = deg;
+            if (deg == 0) cachedIsolatedCount++;
         }
-        return max;
+    }
+
+    /** Maximum degree among all visible nodes. */
+    public int getMaxDegree() {
+        ensureVertexStatsComputed();
+        return cachedMaxDegree;
     }
 
     /**
      * Returns the top-N nodes by degree (most connected).
      * Each entry is "nodeId (degree)".
+     *
+     * <p>Uses a partial-sort (min-heap of size N) instead of fully sorting
+     * all vertices. For graphs with many nodes but small N, this reduces
+     * complexity from O(V log V) to O(V log N).</p>
      */
     public List<String> getTopNodes(int n) {
-        List<Map.Entry<String, Integer>> entries = new ArrayList<Map.Entry<String, Integer>>();
-        for (String node : graph.getVertices()) {
-            entries.add(new AbstractMap.SimpleEntry<String, Integer>(node, graph.degree(node)));
+        ensureVertexStatsComputed();
+
+        if (n <= 0 || cachedDegreeEntries.isEmpty()) {
+            return new ArrayList<String>();
         }
-        Collections.sort(entries, new Comparator<Map.Entry<String, Integer>>() {
-            public int compare(Map.Entry<String, Integer> a, Map.Entry<String, Integer> b) {
-                return b.getValue().compareTo(a.getValue());
+
+        // Use a min-heap of size n for O(V log N) partial sort
+        PriorityQueue<Map.Entry<String, Integer>> minHeap =
+                new PriorityQueue<Map.Entry<String, Integer>>(n + 1,
+                        new Comparator<Map.Entry<String, Integer>>() {
+                            public int compare(Map.Entry<String, Integer> a,
+                                               Map.Entry<String, Integer> b) {
+                                return a.getValue().compareTo(b.getValue());
+                            }
+                        });
+
+        for (Map.Entry<String, Integer> entry : cachedDegreeEntries) {
+            minHeap.add(entry);
+            if (minHeap.size() > n) {
+                minHeap.poll(); // evict smallest
             }
-        });
-        List<String> result = new ArrayList<String>();
-        int count = Math.min(n, entries.size());
-        for (int i = 0; i < count; i++) {
-            Map.Entry<String, Integer> entry = entries.get(i);
-            result.add("Node " + entry.getKey() + " (" + entry.getValue() + ")");
+        }
+
+        // Extract in descending order
+        List<String> result = new ArrayList<String>(minHeap.size());
+        while (!minHeap.isEmpty()) {
+            Map.Entry<String, Integer> entry = minHeap.poll();
+            result.add(0, "Node " + entry.getKey() + " (" + entry.getValue() + ")");
         }
         return result;
     }
@@ -141,22 +185,28 @@ public int compare(Map.Entry<String, Integer> a, Map.Entry<String, Integer> b) {
      * Number of isolated nodes (degree 0) in the visible graph.
      */
     public int getIsolatedNodeCount() {
-        int count = 0;
-        for (String node : graph.getVertices()) {
-            if (graph.degree(node) == 0) count++;
-        }
-        return count;
+        ensureVertexStatsComputed();
+        return cachedIsolatedCount;
     }
 
+    /**
+     * Cached edge weight statistics computed once.
+     */
+    private double cachedTotalWeight = -1.0;
+
     /**
      * Average edge weight across all visible edges.
+     * Caches the total weight sum to avoid re-iterating edges if called
+     * multiple times.
      */
     public double getAverageWeight() {
         if (graph.getEdgeCount() == 0) return 0.0;
-        double total = 0;
-        for (edge e : graph.getEdges()) {
-            total += e.getWeight();
+        if (cachedTotalWeight < 0) {
+            cachedTotalWeight = 0;
+            for (edge e : graph.getEdges()) {
+                cachedTotalWeight += e.getWeight();
+            }
         }
-        return total / graph.getEdgeCount();
+        return cachedTotalWeight / graph.getEdgeCount();
     }
 }

Gvisual/src/gvisual/ShortestPathFinder.java

@@ -137,6 +137,11 @@ public PathResult findShortestByHops(String source, String target) {
     /**
      * Finds the shortest path by total edge weight (Dijkstra) between source and target.
      *
+     * <p>Uses a typed priority queue entry instead of encoding vertices as
+     * double-array indices into a separate vertex list. This eliminates the
+     * O(V) vertex-index map construction and avoids integer-to-double-to-integer
+     * conversion overhead on every PQ operation.</p>
+     *
      * @param source source vertex ID
      * @param target target vertex ID
      * @return the weight-optimal path, or null if no path exists
@@ -153,34 +158,30 @@ public PathResult findShortestByWeight(String source, String target) {
                     0.0);
         }
 
-        // Dijkstra
-        Map<String, Double> dist = new HashMap<String, Double>();
+        // Dijkstra with typed PQ entries (no vertex-index indirection)
+        final Map<String, Double> dist = new HashMap<String, Double>();
         Map<String, String> predecessor = new HashMap<String, String>();
         Map<String, edge> predecessorEdge = new HashMap<String, edge>();
-        // Priority queue: [distance, vertex]
-        PriorityQueue<double[]> pq = new PriorityQueue<double[]>(11, new Comparator<double[]>() {
-            public int compare(double[] a, double[] b) {
-                return Double.compare(a[0], b[0]);
+
+        // Priority queue using String[] wrapper: [0]=vertex, distance stored in dist map
+        PriorityQueue<String> pq = new PriorityQueue<String>(11, new Comparator<String>() {
+            public int compare(String a, String b) {
+                Double da = dist.get(a);
+                Double db = dist.get(b);
+                if (da == null) da = Double.MAX_VALUE;
+                if (db == null) db = Double.MAX_VALUE;
+                return Double.compare(da, db);
             }
         });
 
-        // Use a map of vertex->index for the PQ (encode vertex as string hash)
-        Map<String, Integer> vertexIndex = new HashMap<String, Integer>();
-        List<String> vertexList = new ArrayList<String>(graph.getVertices());
-        for (int i = 0; i < vertexList.size(); i++) {
-            vertexIndex.put(vertexList.get(i), i);
-        }
-
         dist.put(source, 0.0);
         predecessor.put(source, null);
-        pq.add(new double[]{0.0, vertexIndex.get(source)});
+        pq.add(source);
 
         Set<String> visited = new HashSet<String>();
 
         while (!pq.isEmpty()) {
-            double[] entry = pq.poll();
-            int idx = (int) entry[1];
-            String current = vertexList.get(idx);
+            String current = pq.poll();
 
             if (visited.contains(current)) continue;
             visited.add(current);
@@ -202,7 +203,7 @@ public int compare(double[] a, double[] b) {
                     dist.put(neighbor, newDist);
                     predecessor.put(neighbor, current);
                     predecessorEdge.put(neighbor, e);
-                    pq.add(new double[]{newDist, vertexIndex.get(neighbor)});
+                    pq.add(neighbor);
                 }
             }
         }
@@ -241,11 +242,37 @@ public Set<String> getReachableVertices(String source) {
 
     /**
      * Checks whether two vertices are connected (in the same component).
+     *
+     * <p>Uses an early-termination BFS instead of computing the full
+     * reachable set. This is O(component) in the worst case but returns
+     * immediately when the target is found, which is faster for large
+     * graphs where the target is close to the source.</p>
      */
     public boolean areConnected(String source, String target) {
         validateVertex(source, "Source");
         validateVertex(target, "Target");
-        return getReachableVertices(source).contains(target);
+
+        if (source.equals(target)) return true;
+
+        Set<String> visited = new HashSet<String>();
+        Queue<String> queue = new LinkedList<String>();
+
+        visited.add(source);
+        queue.add(source);
+
+        while (!queue.isEmpty()) {
+            String current = queue.poll();
+            for (edge e : graph.getIncidentEdges(current)) {
+                String neighbor = getOtherEnd(e, current);
+                if (neighbor != null && !visited.contains(neighbor)) {
+                    if (neighbor.equals(target)) return true;
+                    visited.add(neighbor);
+                    queue.add(neighbor);
+                }
+            }
+        }
+
+        return false;
     }
 
     // --- private helpers ---