Formatted Graph.java DFSrecursive.java and MonotonicArray.java with clang-format

Author: SlyyJavii

DFSrecursive.java

@@ -1,8 +1,8 @@
 /*
  * This is a recursive implementation of the Depth-First Search (DFS) algorithm.
  * DFS explores as far as possible along each branch before backtracking.
- * 
- * For more details, refer to: 
+ *
+ * For more details, refer to:
  * https://en.wikipedia.org/wiki/Depth-first_search
  */
 
@@ -12,42 +12,37 @@ public class DFSrecursive {
 
     private int[] visited;
 
-    //initializes the visited array for the number of vertices
-    public DFSrecursive(int numVertices)
-    {
-        this.visited = new int [numVertices];
+    // initializes the visited array for the number of vertices
+    public DFSrecursive(int numVertices) {
+        this.visited = new int[numVertices];
     }
 
-    //recursive dfs to check if there is a path from src to dest
-    public boolean dfsPathCheck(graph g, int v, int dest)
-    {
+    // recursive dfs to check if there is a path from src to dest
+    public boolean dfsPathCheck(Graph g, int v, int dest) {
         int numVertices = g.getNumVertices();
-        for(int w = 0; w < numVertices; w++)
-        {
-            if(g.adjacent(v, w) && visited[w] == -1)
-            {
+        for (int w = 0; w < numVertices; w++) {
+            if (g.adjacent(v, w) && visited[w] == -1) {
                 visited[w] = v;
-                if(w == dest){
+                if (w == dest) {
                     return true;
-                }else if (dfsPathCheck(g, w, dest)){
+                } else if (dfsPathCheck(g, w, dest)) {
                     return true;
                 }
-            } 
+            }
         }
         return false;
     }
 
-    public boolean findPathDFS(graph g, int src, int dest)
-    {
-        Arrays.fill(visited, -1);//reset visited array
+    public boolean findPathDFS(Graph g, int src, int dest) {
+        Arrays.fill(visited, -1); // reset visited array
         visited[src] = src;
         return dfsPathCheck(g, src, dest);
     }
 
     public static void main(String[] args) {
 
         int V = 6;
-        graph g = new graph(V);
+        Graph g = new Graph(V);
 
         g.insertEdge(0, 1);
         g.insertEdge(0, 4);
@@ -61,20 +56,16 @@ public static void main(String[] args) {
 
         DFSrecursive dfs = new DFSrecursive(g.getNumVertices());
         int src = 0, dest = 5;
-        if(dfs.findPathDFS(g, src, dest))
-        {
+        if (dfs.findPathDFS(g, src, dest)) {
             System.out.print("Path found: ");
             int v = dest;
-            while(v != src)
-            {
+            while (v != src) {
                 System.out.print(v + " <- ");
                 v = dfs.visited[v];
             }
             System.out.println(src);
-        }else{
+        } else {
             System.out.println("No path found from " + src + " to " + dest);
         }
-    
     }
-
-}
+}

MonotonicArray.java

@@ -1,7 +1,7 @@
 /*
  * This function checks if an array is monotonic.
  * An array is monotonic if it is either entirely non-increasing or non-decreasing.
- * 
+ *
  * For more details, refer to:
  * https://leetcode.com/problems/monotonic-array/
  */
@@ -18,16 +18,16 @@
 */
 
 public class MonotonicArray {
-    //Function to test if list is monotonic
+    // Function to test if list is monotonic
     public static boolean isMonotonic(List<Integer> nums) {
-        //Checks that list is always increasing
+        // Checks that list is always increasing
         boolean increasing = true;
-        //Checks that list is always decreasing
+        // Checks that list is always decreasing
         boolean decreasing = true;
 
-        //Iterates through list to update boolean flag based on +/-
+        // Iterates through list to update boolean flag based on +/-
         for (int i = 0; i < nums.size() - 1; i++) {
-            //If first number is less than the next, it is not increasing
+            // If first number is less than the next, it is not increasing
             if (nums.get(i) < nums.get(i + 1)) {
                 decreasing = false;
             }
@@ -36,13 +36,13 @@ public static boolean isMonotonic(List<Integer> nums) {
                 increasing = false;
             }
         }
-        //List will return if monotonic
+        // List will return if monotonic
         return increasing || decreasing;
     }
-    //Test case for isMonotonic function
+    // Test case for isMonotonic function
     public static void main(String[] args) {
-        System.out.println(isMonotonic(List.of(75, 64, 45, 36)));  // Output: true
-        System.out.println(isMonotonic(List.of(35, 45, 65, 85)));  // Output: true
+        System.out.println(isMonotonic(List.of(75, 64, 45, 36))); // Output: true
+        System.out.println(isMonotonic(List.of(35, 45, 65, 85))); // Output: true
         System.out.println(isMonotonic(List.of(100, 56, 89)));
         System.out.println(isMonotonic(List.of(58394, 134569, 89002)));
     }