added clang-format and updated javadoc

Author: StathisVeinoglou

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

@@ -3,16 +3,20 @@
 import java.util.*;
 
 /**
- * Graph traversals and utilities.
- *
- * <p>This class includes a DFS variant that visits a successor only when
- * <b>all</b> of its predecessors have already been visited. For each step,
- * it emits an event either for a visit (with an increasing order) or for a skip
- * explaining that not all parents were visited yet.</p>
- *
- * <p>Input is an adjacency list of successors. If a predecessor map is not
- * provided, it is derived once from the successors map.</p>
+ * DFS that visits a successor only when all its predecessors are already visited,
+ * emitting VISIT and SKIP events.
+ * <p>
+ *     This class includes a DFS variant that visits a successor only when all of its
+ *     predecessors have already been visited
+ * </p>
+ * <p>Related reading:
+ * <ul>
+ *   <li><a href="https://en.wikipedia.org/wiki/Topological_sorting">Topological sorting</a></li>
+ *   <li><a href="https://en.wikipedia.org/wiki/Depth-first_search">Depth-first search</a></li>
+ * </ul>
+ * </p>
  */
+
 public final class GraphTraversal {
 
     private GraphTraversal() {
@@ -23,7 +27,7 @@ private GraphTraversal() {
     public static final class TraversalEvent<T> {
         private final T node;
         private final Integer order; // non-null for visit, null for skip
-        private final String note;   // non-null for skip, null for visit
+        private final String note; // non-null for skip, null for visit
 
         private TraversalEvent(T node, Integer order, String note) {
             this.node = node;
@@ -41,13 +45,24 @@ public static <T> TraversalEvent<T> skip(T node, String note) {
             return new TraversalEvent<>(Objects.requireNonNull(node), null, Objects.requireNonNull(note));
         }
 
-        public boolean isVisit() { return order != null; }
-        public boolean isSkip() { return order == null; }
-        public T node() { return node; }
-        public Integer order() { return order; }
-        public String note() { return note; }
+        public boolean isVisit() {
+            return order != null;
+        }
+        public boolean isSkip() {
+            return order == null;
+        }
+        public T node() {
+            return node;
+        }
+        public Integer order() {
+            return order;
+        }
+        public String note() {
+            return note;
+        }
 
-        @Override public String toString() {
+        @Override
+        public String toString() {
             return isVisit() ? "VISIT(" + node + ", order=" + order + ")" : "SKIP(" + node + ", " + note + ")";
         }
     }
@@ -77,8 +92,7 @@ public static <T> List<TraversalEvent<T>> dfsRecursiveOrder(Map<T, List<T>> succ
     /**
      * Same as {@link #dfsRecursiveOrder(Map, Object)} but with an explicit predecessors map.
      */
-    public static <T> List<TraversalEvent<T>> dfsRecursiveOrder(
-            Map<T, List<T>> successors, Map<T, List<T>> predecessors, T start) {
+    public static <T> List<TraversalEvent<T>> dfsRecursiveOrder(Map<T, List<T>> successors, Map<T, List<T>> predecessors, T start) {
 
         if (successors == null || predecessors == null) {
             throw new IllegalArgumentException("successors and predecessors must not be null");
@@ -97,13 +111,7 @@ public static <T> List<TraversalEvent<T>> dfsRecursiveOrder(
         return Collections.unmodifiableList(events);
     }
 
-    private static <T> void dfs(
-            T u,
-            Map<T, List<T>> succ,
-            Map<T, List<T>> pred,
-            Set<T> visited,
-            int[] order,
-            List<TraversalEvent<T>> out) {
+    private static <T> void dfs(T u, Map<T, List<T>> succ, Map<T, List<T>> pred, Set<T> visited, int[] order, List<TraversalEvent<T>> out) {
 
         if (!visited.add(u)) {
             return; // already visited

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

@@ -25,7 +25,7 @@ void dfsRecursiveOrder_emitsSkipUntilAllParentsVisited() {
 
         // Expect visits in order and a skip for first time we meet D (via B) before C is visited.
         var visits = events.stream().filter(TraversalEvent::isVisit).toList();
-        var skips  = events.stream().filter(TraversalEvent::isSkip).toList();
+        var skips = events.stream().filter(TraversalEvent::isSkip).toList();
 
         // Visits should be A(0), B(1), C(2), D(3) in some deterministic order given adjacency
         assertThat(visits).hasSize(4);