fix: Apply all formatting, style, and efficiency fixes

Author: sairamsharan

src/main/java/com/thealgorithms/graph/HierholzerAlgorithm.java

@@ -9,83 +9,51 @@
 import java.util.Set;
 import java.util.Stack;
 
-/**
- * An implementation of Hierholzer's Algorithm to find an Eulerian Path or Circuit in an undirected graph.
- * An Eulerian path is a trail in a graph that visits every edge exactly once.
- * An Eulerian circuit is an Eulerian path that starts and ends at the same vertex.
- *
- * Wikipedia: https://en.wikipedia.org/wiki/Eulerian_path#Hierholzer's_algorithm
- */
 public class HierholzerAlgorithm {
 
-    private final int numVertices;
     private final Map<Integer, LinkedList<Integer>> graph;
 
-    /**
-     * Constructor for the algorithm.
-     * @param graph The graph represented as an adjacency list.
-     * Using a LinkedList for neighbors is efficient for edge removal.
-     */
     public HierholzerAlgorithm(Map<Integer, LinkedList<Integer>> graph) {
-        if (graph == null) {
-            this.graph = new HashMap<>();
-            this.numVertices = 0;
-            return;
-        }
-        this.graph = graph;
-        this.numVertices = graph.size();
+        this.graph = (graph == null) ? new HashMap<>() : graph;
     }
 
-    /**
-     * Checks if an Eulerian circuit exists in the undirected graph.
-     * Condition: All vertices with a non-zero degree must be in a single connected component,
-     * and all vertices must have an even degree.
-     * @return true if a circuit exists, false otherwise.
-     */
     public boolean hasEulerianCircuit() {
         if (graph.isEmpty()) {
-            return true; // An empty graph has an empty circuit.
+            return true;
         }
 
-        // Check 1: All vertices must have an even degree.
-        for (int vertex : graph.keySet()) {
-            if (graph.get(vertex).size() % 2 != 0) {
-                return false; // Found a vertex with an odd degree.
+        // FINAL FIX: Loop over values directly for efficiency.
+        for (List<Integer> neighbors : graph.values()) {
+            if (neighbors.size() % 2 != 0) {
+                return false;
             }
         }
 
-        // Check 2: All vertices with edges must be connected.
         if (!isCoherentlyConnected()) {
             return false;
         }
 
         return true;
     }
 
-    /**
-     * Finds the Eulerian circuit.
-     * @return A list of vertices representing the circuit, or an empty list if none exists.
-     */
     public List<Integer> findEulerianCircuit() {
         if (!hasEulerianCircuit()) {
             return Collections.emptyList();
         }
 
-        // Create a copy of the graph to avoid modifying the original during traversal.
         Map<Integer, LinkedList<Integer>> tempGraph = new HashMap<>();
         for (Map.Entry<Integer, LinkedList<Integer>> entry : graph.entrySet()) {
             tempGraph.put(entry.getKey(), new LinkedList<>(entry.getValue()));
         }
 
-        // Data structures for the algorithm.
         Stack<Integer> currentPath = new Stack<>();
         List<Integer> circuit = new LinkedList<>();
 
-        // Find a starting vertex (any vertex with edges).
         int startVertex = -1;
-        for (int vertex : tempGraph.keySet()) {
-            if (!tempGraph.get(vertex).isEmpty()) {
-                startVertex = vertex;
+        // FINAL FIX: Use entrySet for efficiency.
+        for (Map.Entry<Integer, LinkedList<Integer>> entry : tempGraph.entrySet()) {
+            if (!entry.getValue().isEmpty()) {
+                startVertex = entry.getKey();
                 break;
             }
         }
@@ -94,36 +62,26 @@ public List<Integer> findEulerianCircuit() {
             if (graph.isEmpty()) {
                 return Collections.emptyList();
             }
-            return Collections.singletonList(graph.keySet().iterator().next()); // Graph with one isolated vertex.
+            return Collections.singletonList(graph.keySet().iterator().next());
         }
 
         currentPath.push(startVertex);
 
         while (!currentPath.isEmpty()) {
             int currentVertex = currentPath.peek();
 
-            // If the current vertex has unvisited edges
             if (tempGraph.containsKey(currentVertex) && !tempGraph.get(currentVertex).isEmpty()) {
-                int nextVertex = tempGraph.get(currentVertex).pollFirst(); // Get a neighbor
-
-                // Remove the reverse edge as well (for undirected graph)
+                int nextVertex = tempGraph.get(currentVertex).pollFirst();
                 tempGraph.get(nextVertex).remove(Integer.valueOf(currentVertex));
-
-                // Push the neighbor to the stack to continue the tour
                 currentPath.push(nextVertex);
             } else {
-                // If "stuck" (no more edges), backtrack and add to the final circuit.
                 circuit.add(0, currentPath.pop());
             }
         }
 
         return circuit;
     }
 
-    /**
-     * Helper method to check if all vertices with a non-zero degree are connected.
-     * Uses a simple traversal (DFS).
-     */
     private boolean isCoherentlyConnected() {
         if (graph.isEmpty()) {
             return true;
@@ -132,26 +90,24 @@ private boolean isCoherentlyConnected() {
         Set<Integer> visited = new HashSet<>();
         int startNode = -1;
 
-        // Find the first vertex with a degree greater than 0
-        for (int vertex : graph.keySet()) {
-            if (!graph.get(vertex).isEmpty()) {
-                startNode = vertex;
+        // FINAL FIX: Use entrySet for efficiency.
+        for (Map.Entry<Integer, LinkedList<Integer>> entry : graph.entrySet()) {
+            if (!entry.getValue().isEmpty()) {
+                startNode = entry.getKey();
                 break;
             }
         }
 
-        // If no edges in the graph, it's connected.
         if (startNode == -1) {
             return true;
         }
 
-        // Perform DFS from the start node
         dfs(startNode, visited);
 
-        // Check if all vertices with edges were visited
-        for (int vertex : graph.keySet()) {
-            if (!graph.get(vertex).isEmpty() && !visited.contains(vertex)) {
-                return false; // Found a vertex with edges that wasn't visited
+        // FINAL FIX: Use entrySet for efficiency.
+        for (Map.Entry<Integer, LinkedList<Integer>> entry : graph.entrySet()) {
+            if (!entry.getValue().isEmpty() && !visited.contains(entry.getKey())) {
+                return false;
             }
         }
         return true;

src/test/java/com/thealgorithms/graph/HierholzerAlgorithmTest.java

@@ -16,55 +16,37 @@ public class HierholzerAlgorithmTest {
 
     @Test
     public void testFindsEulerianCircuitInSimpleTriangleGraph() {
-        // Create a simple triangle graph where a circuit definitely exists: 0-1, 1-2, 2-0
         Map<Integer, LinkedList<Integer>> graph = new HashMap<>();
         graph.put(0, new LinkedList<>(Arrays.asList(1, 2)));
         graph.put(1, new LinkedList<>(Arrays.asList(0, 2)));
         graph.put(2, new LinkedList<>(Arrays.asList(0, 1)));
-
         HierholzerAlgorithm algorithm = new HierholzerAlgorithm(graph);
-
-        // Verify that the algorithm agrees a circuit exists
         assertTrue(algorithm.hasEulerianCircuit());
-
         List<Integer> circuit = algorithm.findEulerianCircuit();
-
-        // A valid circuit for a triangle has 3 edges, so the path will have 4 vertices (e.g., 0 -> 1 -> 2 -> 0)
         assertEquals(4, circuit.size());
-
-        // The path must start and end at the same vertex
         assertEquals(circuit.get(0), circuit.get(circuit.size() - 1));
     }
 
     @Test
     public void testFailsForGraphWithOddDegreeVertices() {
-        // Create a graph where vertices 0 and 1 have an odd degree (1)
         Map<Integer, LinkedList<Integer>> graph = new HashMap<>();
         graph.put(0, new LinkedList<>(Collections.singletonList(1)));
         graph.put(1, new LinkedList<>(Collections.singletonList(0)));
-
         HierholzerAlgorithm algorithm = new HierholzerAlgorithm(graph);
-
-        // The algorithm should correctly identify that no circuit exists
         assertFalse(algorithm.hasEulerianCircuit());
-        // The find method should return an empty list
         assertTrue(algorithm.findEulerianCircuit().isEmpty());
     }
 
     @Test
     public void testFailsForDisconnectedGraph() {
-        // Create a graph with two separate triangles (0-1-2 and 3-4-5)
         Map<Integer, LinkedList<Integer>> graph = new HashMap<>();
         graph.put(0, new LinkedList<>(Arrays.asList(1, 2)));
         graph.put(1, new LinkedList<>(Arrays.asList(0, 2)));
         graph.put(2, new LinkedList<>(Arrays.asList(0, 1)));
         graph.put(3, new LinkedList<>(Arrays.asList(4, 5)));
         graph.put(4, new LinkedList<>(Arrays.asList(3, 5)));
         graph.put(5, new LinkedList<>(Arrays.asList(3, 4)));
-
         HierholzerAlgorithm algorithm = new HierholzerAlgorithm(graph);
-
-        // All degrees are even, but the graph is not connected, so no circuit exists
         assertFalse(algorithm.hasEulerianCircuit());
     }