Added Hierholzer Algorith to find Eulerian Path

Author: crashmovies

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

@@ -112,28 +112,44 @@ public List<Integer> findEulerianPath() {
 
         int[] inDegree = new int[n];
         int[] outDegree = new int[n];
-        int edgeCount = 0;
+        int edgeCount = computeDegrees(inDegree, outDegree);
+
+        // no edges -> single vertex response requested by tests: [0]
+        if (edgeCount == 0) {
+            return Collections.singletonList(0);
+        }
+
+        int startNode = determineStartNode(inDegree, outDegree);
+        if (startNode == -1) return new ArrayList<>();
+
+        if (!allNonZeroDegreeVerticesWeaklyConnected(startNode, n, outDegree, inDegree)) {
+            return new ArrayList<>();
+        }
+
+        List<Integer> path = buildHierholzerPath(startNode, n);
+        if (path.size() != edgeCount + 1) return new ArrayList<>();
+
+        return rotateEulerianCircuitIfNeeded(path, outDegree, inDegree);
+    }
 
-        // compute degrees and total edges
-        for (int u = 0; u < n; u++) {
+    private int computeDegrees(int[] inDegree, int[] outDegree) {
+        int edgeCount = 0;
+        for (int u = 0; u < graph.getNumNodes(); u++) {
             for (int v : graph.getEdges(u)) {
                 outDegree[u]++;
                 inDegree[v]++;
                 edgeCount++;
             }
         }
+        return edgeCount;
+    }
 
-        // no edges -> single vertex response requested by tests: [0]
-        if (edgeCount == 0) {
-            // If there is at least one vertex, tests expect [0] for single-node graphs with no edges.
-            // For n >= 1, return [0]. (Tests create Graph(1) for that case.)
-            return Collections.singletonList(0);
-        }
-
-        // Check degree differences to determine Eulerian path/circuit possibility
+    private int determineStartNode(int[] inDegree, int[] outDegree) {
+        int n = graph.getNumNodes();
         int startNode = -1;
         int startCount = 0;
         int endCount = 0;
+
         for (int i = 0; i < n; i++) {
             int diff = outDegree[i] - inDegree[i];
             if (diff == 1) {
@@ -142,16 +158,14 @@ public List<Integer> findEulerianPath() {
             } else if (diff == -1) {
                 endCount++;
             } else if (Math.abs(diff) > 1) {
-                return new ArrayList<>(); // invalid degree difference
+                return -1;
             }
         }
 
-        // Must be either exactly one start and one end (path) or zero of both (circuit)
         if (!((startCount == 1 && endCount == 1) || (startCount == 0 && endCount == 0))) {
-            return new ArrayList<>();
+            return -1;
         }
 
-        // If circuit, choose smallest-index vertex with outgoing edges (deterministic for tests)
         if (startNode == -1) {
             for (int i = 0; i < n; i++) {
                 if (outDegree[i] > 0) {
@@ -160,79 +174,67 @@ public List<Integer> findEulerianPath() {
                 }
             }
         }
+        return startNode;
+    }
 
-        if (startNode == -1) {
-            return new ArrayList<>();
-        }
-
-        // Weak connectivity check: every vertex with non-zero degree must be in the same weak component.
-        if (!allNonZeroDegreeVerticesWeaklyConnected(startNode, n, outDegree, inDegree)) {
-            return new ArrayList<>();
-        }
-
-        // Create modifiable adjacency structure for traversal
+    private List<Integer> buildHierholzerPath(int startNode, int n) {
         List<Deque<Integer>> tempAdj = new ArrayList<>();
         for (int i = 0; i < n; i++) {
             tempAdj.add(new ArrayDeque<>(graph.getEdges(i)));
         }
 
-        // Hierholzer's traversal using stack
         Deque<Integer> stack = new ArrayDeque<>();
         List<Integer> path = new ArrayList<>();
         stack.push(startNode);
 
         while (!stack.isEmpty()) {
             int u = stack.peek();
             if (!tempAdj.get(u).isEmpty()) {
-                int v = tempAdj.get(u).pollFirst();
-                stack.push(v);
+                stack.push(tempAdj.get(u).pollFirst());
             } else {
                 path.add(stack.pop());
             }
         }
 
-        // Path is recorded in reverse
         Collections.reverse(path);
+        return path;
+    }
 
-        // Ensure all edges were used
-        if (path.size() != edgeCount + 1) {
-            return new ArrayList<>();
+    private List<Integer> rotateEulerianCircuitIfNeeded(List<Integer> path, int[] outDegree, int[] inDegree) {
+        int startCount = 0;
+        int endCount = 0;
+        for (int i = 0; i < outDegree.length; i++) {
+            int diff = outDegree[i] - inDegree[i];
+            if (diff == 1)
+                startCount++;
+            else if (diff == -1)
+                endCount++;
         }
 
-        // If Eulerian circuit (startCount==0 && endCount==0), rotate path so it starts at
-        // the smallest-index vertex that has outgoing edges (deterministic expected by tests)
-        if (startCount == 0 && endCount == 0) {
+        if (startCount == 0 && endCount == 0 && !path.isEmpty()) {
             int preferredStart = -1;
-            for (int i = 0; i < n; i++) {
+            for (int i = 0; i < outDegree.length; i++) {
                 if (outDegree[i] > 0) {
                     preferredStart = i;
                     break;
                 }
             }
-            if (preferredStart != -1 && !path.isEmpty()) {
-                if (path.get(0) != preferredStart) {
-                    // find index where preferredStart occurs and rotate
-                    int idx = -1;
-                    for (int i = 0; i < path.size(); i++) {
-                        if (path.get(i) == preferredStart) {
-                            idx = i;
-                            break;
-                        }
-                    }
-                    if (idx > 0) {
-                        List<Integer> rotated = new ArrayList<>();
-                        for (int i = idx; i < path.size(); i++) {
-                            rotated.add(path.get(i));
-                        }
-                        for (int i = 1; i <= idx; i++) {
-                            rotated.add(path.get(i % path.size()));
-                        }
-                        path = rotated;
-                    }
+
+            if (preferredStart != -1 && path.get(0) != preferredStart) {
+                int idx = 0;
+                for (int node : path) {
+                    if (node == preferredStart) break;
+                    idx++;
+                }
+
+                if (idx > 0) {
+                    List<Integer> rotated = new ArrayList<>();
+                    for (int i = idx; i < path.size(); i++) rotated.add(path.get(i));
+                    for (int i = 0; i < idx; i++) rotated.add(path.get(i));
+                    path = rotated;
                 }
             }
         }
-
         return path;
     }
 
@@ -251,17 +253,14 @@ private boolean allNonZeroDegreeVerticesWeaklyConnected(int startNode, int n, in
         stack.push(startNode);
         visited[startNode] = true;
 
-        // Build undirected adjacency on the fly: for each u -> v, consider u - v
         while (!stack.isEmpty()) {
             int u = stack.pop();
-            // neighbors: outgoing edges
             for (int v : graph.getEdges(u)) {
                 if (!visited[v]) {
                     visited[v] = true;
                     stack.push(v);
                 }
             }
-            // neighbors: incoming edges (we must scan all vertices to find incoming edges)
             for (int x = 0; x < n; x++) {
                 if (!visited[x]) {
                     for (int y : graph.getEdges(x)) {
@@ -275,7 +274,6 @@ private boolean allNonZeroDegreeVerticesWeaklyConnected(int startNode, int n, in
             }
         }
 
-        // check all vertices with non-zero degree are visited
         for (int i = 0; i < n; i++) {
             if (outDegree[i] + inDegree[i] > 0 && !visited[i]) {
                 return false;