fix: format files using clang

Author: LucasAHorn

.github/pull_request_template.md

@@ -8,9 +8,9 @@ In order to reduce the number of notifications sent to the maintainers, please:
 
 <!-- For completed items, change [ ] to [x] -->
 
-- [ ] I have read [CONTRIBUTING.md](https://github.com/TheAlgorithms/Java/blob/master/CONTRIBUTING.md).
-- [ ] This pull request is all my own work -- I have not plagiarized it.
-- [ ] All filenames are in PascalCase.
-- [ ] All functions and variable names follow Java naming conventions.
-- [ ] All new algorithms have a URL in their comments that points to Wikipedia or other similar explanations.
-- [ ] All new code is formatted with `clang-format -i --style=file path/to/your/file.java`
+- [X] I have read [CONTRIBUTING.md](https://github.com/TheAlgorithms/Java/blob/master/CONTRIBUTING.md).
+- [X] This pull request is all my own work -- I have not plagiarized it.
+- [X] All filenames are in PascalCase.
+- [X] All functions and variable names follow Java naming conventions.
+- [X] All new algorithms have a URL in their comments that points to Wikipedia or other similar explanations.
+- [X] All new code is formatted with `clang-format -i --style=file path/to/your/file.java`

src/test/java/com/thealgorithms/datastructures/graphs/DijkstraAlgorithmTest.java

@@ -15,45 +15,45 @@ public class DijkstraAlgorithmTest {
     @BeforeEach
     void setUp() {
         graph = new int[][] {
-                { 0, 4, 0, 0, 0, 0, 0, 8, 0 },
-                { 4, 0, 8, 0, 0, 0, 0, 11, 0 },
-                { 0, 8, 0, 7, 0, 4, 0, 0, 2 },
-                { 0, 0, 7, 0, 9, 14, 0, 0, 0 },
-                { 0, 0, 0, 9, 0, 10, 0, 0, 0 },
-                { 0, 0, 4, 14, 10, 0, 2, 0, 0 },
-                { 0, 0, 0, 0, 0, 2, 0, 1, 6 },
-                { 8, 11, 0, 0, 0, 0, 1, 0, 7 },
-                { 0, 0, 2, 0, 0, 0, 6, 7, 0 },
+            {0, 4, 0, 0, 0, 0, 0, 8, 0},
+            {4, 0, 8, 0, 0, 0, 0, 11, 0},
+            {0, 8, 0, 7, 0, 4, 0, 0, 2},
+            {0, 0, 7, 0, 9, 14, 0, 0, 0},
+            {0, 0, 0, 9, 0, 10, 0, 0, 0},
+            {0, 0, 4, 14, 10, 0, 2, 0, 0},
+            {0, 0, 0, 0, 0, 2, 0, 1, 6},
+            {8, 11, 0, 0, 0, 0, 1, 0, 7},
+            {0, 0, 2, 0, 0, 0, 6, 7, 0},
         };
 
         dijkstraAlgorithm = new DijkstraAlgorithm(graph.length);
     }
 
     @Test
     void testRunAlgorithm() {
-        int[] expectedDistances = { 0, 4, 12, 19, 21, 11, 9, 8, 14 };
+        int[] expectedDistances = {0, 4, 12, 19, 21, 11, 9, 8, 14};
         assertArrayEquals(expectedDistances, dijkstraAlgorithm.run(graph, 0));
     }
 
     @Test
     void testGraphWithDisconnectedNodes() {
         int[][] disconnectedGraph = {
-                { 0, 3, 0, 0 }, { 3, 0, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 } // Node 3 is disconnected
+            {0, 3, 0, 0}, {3, 0, 1, 0}, {0, 1, 0, 0}, {0, 0, 0, 0} // Node 3 is disconnected
         };
 
         DijkstraAlgorithm dijkstraDisconnected = new DijkstraAlgorithm(disconnectedGraph.length);
 
         // Testing from vertex 0
-        int[] expectedDistances = { 0, 3, 4, Integer.MAX_VALUE }; // Node 3 is unreachable
+        int[] expectedDistances = {0, 3, 4, Integer.MAX_VALUE}; // Node 3 is unreachable
         assertArrayEquals(expectedDistances, dijkstraDisconnected.run(disconnectedGraph, 0));
     }
 
     @Test
     void testSingleVertexGraph() {
-        int[][] singleVertexGraph = { { 0 } };
+        int[][] singleVertexGraph = {{0}};
         DijkstraAlgorithm dijkstraSingleVertex = new DijkstraAlgorithm(1);
 
-        int[] expectedDistances = { 0 }; // The only vertex's distance to itself is 0
+        int[] expectedDistances = {0}; // The only vertex's distance to itself is 0
         assertArrayEquals(expectedDistances, dijkstraSingleVertex.run(singleVertexGraph, 0));
     }
 
@@ -67,17 +67,12 @@ void testInvalidSourceVertex() {
     void testLinearGraph() {
         // Linear graph: 0 - 1 - 2 - 3
         // with weights: 2 3 4
-        int[][] linearGraph = {
-                { 0, 2, 0, 0 },
-                { 2, 0, 3, 0 },
-                { 0, 3, 0, 4 },
-                { 0, 0, 4, 0 }
-        };
+        int[][] linearGraph = {{0, 2, 0, 0}, {2, 0, 3, 0}, {0, 3, 0, 4}, {0, 0, 4, 0}};
 
         DijkstraAlgorithm dijkstraLinear = new DijkstraAlgorithm(4);
         int[] distances = dijkstraLinear.run(linearGraph, 0);
 
-        assertArrayEquals(new int[] { 0, 2, 5, 9 }, distances);
+        assertArrayEquals(new int[] {0, 2, 5, 9}, distances);
     }
 
     @Test
@@ -88,107 +83,79 @@ void testStarTopology() {
         // 3(4)-0-2(3)
         // |
         // 4(5)
-        int[][] starGraph = {
-                { 0, 2, 3, 4, 5 },
-                { 2, 0, 0, 0, 0 },
-                { 3, 0, 0, 0, 0 },
-                { 4, 0, 0, 0, 0 },
-                { 5, 0, 0, 0, 0 }
-        };
+        int[][] starGraph = {{0, 2, 3, 4, 5}, {2, 0, 0, 0, 0}, {3, 0, 0, 0, 0}, {4, 0, 0, 0, 0}, {5, 0, 0, 0, 0}};
 
         DijkstraAlgorithm dijkstraStar = new DijkstraAlgorithm(5);
         int[] distances = dijkstraStar.run(starGraph, 0);
 
-        assertArrayEquals(new int[] { 0, 2, 3, 4, 5 }, distances);
+        assertArrayEquals(new int[] {0, 2, 3, 4, 5}, distances);
     }
 
     @Test
     void testCompleteGraphK4() {
         // Complete graph K4 with varying weights
-        int[][] completeGraph = {
-                { 0, 1, 2, 3 },
-                { 1, 0, 4, 5 },
-                { 2, 4, 0, 6 },
-                { 3, 5, 6, 0 }
-        };
+        int[][] completeGraph = {{0, 1, 2, 3}, {1, 0, 4, 5}, {2, 4, 0, 6}, {3, 5, 6, 0}};
 
         DijkstraAlgorithm dijkstraComplete = new DijkstraAlgorithm(4);
         int[] distances = dijkstraComplete.run(completeGraph, 0);
 
         // Direct paths from 0 are shortest
-        assertArrayEquals(new int[] { 0, 1, 2, 3 }, distances);
+        assertArrayEquals(new int[] {0, 1, 2, 3}, distances);
     }
 
     @Test
     void testDifferentSourceVertex() {
         // Test running from different source vertices
-        int[][] simpleGraph = {
-                { 0, 5, 0, 0 },
-                { 5, 0, 3, 0 },
-                { 0, 3, 0, 2 },
-                { 0, 0, 2, 0 }
-        };
+        int[][] simpleGraph = {{0, 5, 0, 0}, {5, 0, 3, 0}, {0, 3, 0, 2}, {0, 0, 2, 0}};
 
         DijkstraAlgorithm dijkstra = new DijkstraAlgorithm(4);
 
         // From vertex 0
         int[] distFrom0 = dijkstra.run(simpleGraph, 0);
-        assertArrayEquals(new int[] { 0, 5, 8, 10 }, distFrom0);
+        assertArrayEquals(new int[] {0, 5, 8, 10}, distFrom0);
 
         // From vertex 2
         int[] distFrom2 = dijkstra.run(simpleGraph, 2);
-        assertArrayEquals(new int[] { 8, 3, 0, 2 }, distFrom2);
+        assertArrayEquals(new int[] {8, 3, 0, 2}, distFrom2);
 
         // From vertex 3
         int[] distFrom3 = dijkstra.run(simpleGraph, 3);
-        assertArrayEquals(new int[] { 10, 5, 2, 0 }, distFrom3);
+        assertArrayEquals(new int[] {10, 5, 2, 0}, distFrom3);
     }
 
     @Test
     void testUnitWeightGraph() {
         // Graph with all unit weights (like BFS distance)
-        int[][] unitGraph = {
-                { 0, 1, 1, 0 },
-                { 1, 0, 1, 1 },
-                { 1, 1, 0, 1 },
-                { 0, 1, 1, 0 }
-        };
+        int[][] unitGraph = {{0, 1, 1, 0}, {1, 0, 1, 1}, {1, 1, 0, 1}, {0, 1, 1, 0}};
 
         DijkstraAlgorithm dijkstraUnit = new DijkstraAlgorithm(4);
         int[] distances = dijkstraUnit.run(unitGraph, 0);
 
-        assertArrayEquals(new int[] { 0, 1, 1, 2 }, distances);
+        assertArrayEquals(new int[] {0, 1, 1, 2}, distances);
     }
 
     @Test
     void testTwoVertexGraph() {
-        int[][] twoVertexGraph = {
-                { 0, 7 },
-                { 7, 0 }
-        };
+        int[][] twoVertexGraph = {{0, 7}, {7, 0}};
 
         DijkstraAlgorithm dijkstraTwo = new DijkstraAlgorithm(2);
         int[] distances = dijkstraTwo.run(twoVertexGraph, 0);
 
-        assertArrayEquals(new int[] { 0, 7 }, distances);
+        assertArrayEquals(new int[] {0, 7}, distances);
     }
 
     @Test
     void testShortcutPath() {
         // Graph where direct path is longer than indirect path
         // 0 --(10)--> 2
         // 0 --(1)--> 1 --(2)--> 2
-        int[][] shortcutGraph = {
-                { 0, 1, 10 },
-                { 1, 0, 2 },
-                { 10, 2, 0 }
-        };
+        int[][] shortcutGraph = {{0, 1, 10}, {1, 0, 2}, {10, 2, 0}};
 
         DijkstraAlgorithm dijkstraShortcut = new DijkstraAlgorithm(3);
         int[] distances = dijkstraShortcut.run(shortcutGraph, 0);
 
         // The shortest path to vertex 2 should be 3 (via vertex 1), not 10 (direct)
-        assertArrayEquals(new int[] { 0, 1, 3 }, distances);
+        assertArrayEquals(new int[] {0, 1, 3}, distances);
     }
 
     @Test
@@ -204,15 +171,11 @@ void testSourceToSourceDistanceIsZero() {
     @Test
     void testLargeWeights() {
         // Graph with large weights
-        int[][] largeWeightGraph = {
-                { 0, 1000, 0 },
-                { 1000, 0, 2000 },
-                { 0, 2000, 0 }
-        };
+        int[][] largeWeightGraph = {{0, 1000, 0}, {1000, 0, 2000}, {0, 2000, 0}};
 
         DijkstraAlgorithm dijkstraLarge = new DijkstraAlgorithm(3);
         int[] distances = dijkstraLarge.run(largeWeightGraph, 0);
 
-        assertArrayEquals(new int[] { 0, 1000, 3000 }, distances);
+        assertArrayEquals(new int[] {0, 1000, 3000}, distances);
     }
 }

src/test/java/com/thealgorithms/datastructures/graphs/MatrixGraphsTest.java

@@ -99,9 +99,9 @@ void testToString() {
         graph.addEdge(1, 2);
 
         String expected = "    0 1 2  \n"
-                + "0 : 0 1 0 \n"
-                + "1 : 1 0 1 \n"
-                + "2 : 0 1 0 \n";
+            + "0 : 0 1 0 \n"
+            + "1 : 1 0 1 \n"
+            + "2 : 0 1 0 \n";
 
         assertEquals(expected, graph.toString());
     }