Merge branch 'master' into prim_improve

Author: siriak

DIRECTORY.md

@@ -852,6 +852,7 @@
               * [KosarajuTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/KosarajuTest.java)
               * [KruskalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/KruskalTest.java)
               * [PrimMSTTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/PrimMSTTest.java)
+              * [MatrixGraphsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/MatrixGraphsTest.java)
               * [TarjansAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/TarjansAlgorithmTest.java)
               * [WelshPowellTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/WelshPowellTest.java)
             * hashmap

src/main/java/com/thealgorithms/conversions/HexaDecimalToDecimal.java

@@ -1,39 +1,45 @@
 package com.thealgorithms.conversions;
 
-import java.util.Scanner;
-
+/**
+ * Utility class for converting a hexadecimal string to its decimal representation.
+ * <p>
+ * A hexadecimal number uses the base-16 numeral system, with the following characters:
+ * <ul>
+ *   <li>Digits: 0-9</li>
+ *   <li>Letters: A-F (case-insensitive)</li>
+ * </ul>
+ * Each character represents a power of 16. For example:
+ * <pre>
+ *   Hexadecimal "A1" = 10*16^1 + 1*16^0 = 161 (decimal)
+ * </pre>
+ *
+ * <p>This class provides a method to perform the conversion without using built-in Java utilities.</p>
+ */
 public final class HexaDecimalToDecimal {
     private HexaDecimalToDecimal() {
     }
 
-    // convert hexadecimal to decimal
+    /**
+     * Converts a hexadecimal string to its decimal integer equivalent.
+     * <p>The input string is case-insensitive, and must contain valid hexadecimal characters [0-9, A-F].</p>
+     *
+     * @param hex the hexadecimal string to convert
+     * @return the decimal integer representation of the input hexadecimal string
+     * @throws IllegalArgumentException if the input string contains invalid characters
+     */
     public static int getHexaToDec(String hex) {
         String digits = "0123456789ABCDEF";
         hex = hex.toUpperCase();
         int val = 0;
+
         for (int i = 0; i < hex.length(); i++) {
             int d = digits.indexOf(hex.charAt(i));
+            if (d == -1) {
+                throw new IllegalArgumentException("Invalid hexadecimal character: " + hex.charAt(i));
+            }
             val = 16 * val + d;
         }
-        return val;
-    }
 
-    // Main method gets the hexadecimal input from user and converts it into Decimal output.
-    public static void main(String[] args) {
-        String hexaInput;
-        int decOutput;
-        Scanner scan = new Scanner(System.in);
-
-        System.out.print("Enter Hexadecimal Number : ");
-        hexaInput = scan.nextLine();
-
-        // convert hexadecimal to decimal
-        decOutput = getHexaToDec(hexaInput);
-        /*
-    Pass the string to the getHexaToDec function
-    and it returns the decimal form in the variable decOutput.
-         */
-        System.out.println("Number in Decimal: " + decOutput);
-        scan.close();
+        return val;
     }
 }

src/main/java/com/thealgorithms/datastructures/graphs/MatrixGraphs.java

@@ -102,7 +102,7 @@ public int numberOfVertices() {
     /**
      * Updates the number of edges in the graph
      *
-     * @param newNumberOfEdges
+     * @param newNumberOfEdges the new number of edges
      *
      */
     private void setNumberOfEdges(int newNumberOfEdges) {
@@ -202,7 +202,7 @@ public boolean addEdge(int from, int to) {
      * exists and is removed
      */
     public boolean removeEdge(int from, int to) {
-        if (!this.vertexDoesExist(from) || !this.vertexDoesExist(to)) {
+        if (this.vertexDoesExist(from) && this.vertexDoesExist(to)) {
             if (this.adjacencyOfEdgeDoesExist(from, to)) {
                 this.adjacency()[from][to] = AdjacencyMatrixGraph.EDGE_NONE;
                 this.adjacency()[to][from] = AdjacencyMatrixGraph.EDGE_NONE;
@@ -223,14 +223,14 @@ public boolean removeEdge(int from, int to) {
     public List<Integer> depthFirstOrder(int startVertex) {
         // If the startVertex is invalid, return an empty list
         if (startVertex >= vertexCount || startVertex < 0) {
-            return new ArrayList<Integer>();
+            return new ArrayList<>();
         }
 
         // Create an array to track the visited vertices
         boolean[] visited = new boolean[vertexCount];
 
         // Create a list to keep track of the order of our traversal
-        ArrayList<Integer> orderList = new ArrayList<Integer>();
+        ArrayList<Integer> orderList = new ArrayList<>();
 
         // Perform our DFS algorithm
         depthFirstOrder(startVertex, visited, orderList);
@@ -278,18 +278,18 @@ private void depthFirstOrder(int currentVertex, boolean[] visited, List<Integer>
     public List<Integer> breadthFirstOrder(int startVertex) {
         // If the specified startVertex is invalid, return an empty list
         if (startVertex >= vertexCount || startVertex < 0) {
-            return new ArrayList<Integer>();
+            return new ArrayList<>();
         }
 
         // Create an array to keep track of the visited vertices
         boolean[] visited = new boolean[vertexCount];
 
         // Create a list to keep track of the ordered vertices
-        ArrayList<Integer> orderList = new ArrayList<Integer>();
+        ArrayList<Integer> orderList = new ArrayList<>();
 
         // Create a queue for our BFS algorithm and add the startVertex
         // to the queue
-        Queue<Integer> queue = new LinkedList<Integer>();
+        Queue<Integer> queue = new LinkedList<>();
         queue.add(startVertex);
 
         // Continue until the queue is empty
@@ -327,19 +327,19 @@ public List<Integer> breadthFirstOrder(int startVertex) {
      * @return returns a string describing this graph
      */
     public String toString() {
-        String s = "    ";
+        StringBuilder s = new StringBuilder("    ");
         for (int i = 0; i < this.numberOfVertices(); i++) {
-            s = s + i + " ";
+            s.append(i).append(" ");
         }
-        s = s + " \n";
+        s.append(" \n");
 
         for (int i = 0; i < this.numberOfVertices(); i++) {
-            s = s + i + " : ";
+            s.append(i).append(" : ");
             for (int j = 0; j < this.numberOfVertices(); j++) {
-                s = s + this.adjMatrix[i][j] + " ";
+                s.append(this.adjMatrix[i][j]).append(" ");
             }
-            s = s + "\n";
+            s.append("\n");
         }
-        return s;
+        return s.toString();
     }
 }

src/test/java/com/thealgorithms/conversions/HexaDecimalToDecimalTest.java

@@ -1,14 +1,37 @@
 package com.thealgorithms.conversions;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
 
 public class HexaDecimalToDecimalTest {
 
-    @Test
-    public void testhexaDecimalToDecimal() {
-        assertEquals(161, HexaDecimalToDecimal.getHexaToDec("A1"));
-        assertEquals(428, HexaDecimalToDecimal.getHexaToDec("1ac"));
+    @ParameterizedTest
+    @CsvSource({
+        "A1, 161", // Simple case with two characters
+        "1AC, 428", // Mixed-case input
+        "0, 0", // Single zero
+        "F, 15", // Single digit
+        "10, 16", // Power of 16
+        "FFFF, 65535", // Max 4-character hex
+        "7FFFFFFF, 2147483647" // Max positive int value
+    })
+    public void
+    testValidHexaToDecimal(String hexInput, int expectedDecimal) {
+        assertEquals(expectedDecimal, HexaDecimalToDecimal.getHexaToDec(hexInput));
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+        "G", // Invalid character
+        "1Z", // Mixed invalid input
+        "123G", // Valid prefix with invalid character
+        "#$%" // Non-hexadecimal symbols
+    })
+    public void
+    testInvalidHexaToDecimal(String invalidHex) {
+        assertThrows(IllegalArgumentException.class, () -> HexaDecimalToDecimal.getHexaToDec(invalidHex));
     }
 }

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

@@ -0,0 +1,140 @@
+package com.thealgorithms.datastructures.graphs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Arrays;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class MatrixGraphsTest {
+
+    @Test
+    void testGraphConstruction() {
+        AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(5);
+        assertEquals(5, graph.numberOfVertices());
+        assertEquals(0, graph.numberOfEdges());
+    }
+
+    @Test
+    void testAddEdge() {
+        AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(5);
+        assertTrue(graph.addEdge(0, 1));
+        assertTrue(graph.edgeDoesExist(0, 1));
+        assertTrue(graph.edgeDoesExist(1, 0));
+        assertEquals(1, graph.numberOfEdges());
+
+        // Adding the same edge again should return false
+        assertFalse(graph.addEdge(0, 1));
+        assertFalse(graph.addEdge(5, 1));
+        assertFalse(graph.addEdge(-1, 1));
+    }
+
+    @Test
+    void testRemoveEdge() {
+        AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(5);
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 2);
+
+        assertTrue(graph.removeEdge(0, 1));
+        assertFalse(graph.edgeDoesExist(0, 1));
+        assertFalse(graph.edgeDoesExist(1, 0));
+        assertEquals(1, graph.numberOfEdges());
+
+        assertFalse(graph.removeEdge(0, 3));
+        assertFalse(graph.removeEdge(5, 1));
+        assertFalse(graph.removeEdge(-1, 1));
+    }
+
+    @Test
+    void testVertexDoesExist() {
+        AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(5);
+        assertTrue(graph.vertexDoesExist(0));
+        assertTrue(graph.vertexDoesExist(4));
+        assertFalse(graph.vertexDoesExist(5));
+        assertFalse(graph.vertexDoesExist(-1));
+    }
+
+    @Test
+    void testDepthFirstOrder() {
+        AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(5);
+        graph.addEdge(0, 1);
+        graph.addEdge(0, 2);
+        graph.addEdge(1, 3);
+        graph.addEdge(2, 4);
+
+        List<Integer> dfs = graph.depthFirstOrder(0);
+        assertEquals(5, dfs.size());
+        assertEquals(0, dfs.getFirst());
+
+        assertTrue(dfs.containsAll(Arrays.asList(0, 1, 2, 3, 4)));
+
+        List<Integer> emptyDfs = graph.depthFirstOrder(5);
+        assertTrue(emptyDfs.isEmpty());
+    }
+
+    @Test
+    void testBreadthFirstOrder() {
+        AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(5);
+        graph.addEdge(0, 1);
+        graph.addEdge(0, 2);
+        graph.addEdge(1, 3);
+        graph.addEdge(2, 4);
+
+        List<Integer> bfs = graph.breadthFirstOrder(0);
+        assertEquals(5, bfs.size());
+        assertEquals(0, bfs.getFirst());
+
+        assertTrue(bfs.containsAll(Arrays.asList(0, 1, 2, 3, 4)));
+
+        List<Integer> emptyBfs = graph.breadthFirstOrder(5);
+        assertTrue(emptyBfs.isEmpty());
+    }
+
+    @Test
+    void testToString() {
+        AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(3);
+        graph.addEdge(0, 1);
+        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";
+
+        assertEquals(expected, graph.toString());
+    }
+
+    @Test
+    void testCyclicGraph() {
+        AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(4);
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 3);
+        graph.addEdge(3, 0);
+
+        List<Integer> dfs = graph.depthFirstOrder(0);
+        List<Integer> bfs = graph.breadthFirstOrder(0);
+
+        assertEquals(4, dfs.size());
+        assertEquals(4, bfs.size());
+        assertTrue(dfs.containsAll(Arrays.asList(0, 1, 2, 3)));
+        assertTrue(bfs.containsAll(Arrays.asList(0, 1, 2, 3)));
+    }
+
+    @Test
+    void testDisconnectedGraph() {
+        AdjacencyMatrixGraph graph = new AdjacencyMatrixGraph(5);
+        graph.addEdge(0, 1);
+        graph.addEdge(2, 3);
+
+        List<Integer> dfs = graph.depthFirstOrder(0);
+        List<Integer> bfs = graph.breadthFirstOrder(0);
+
+        assertEquals(2, dfs.size());
+        assertEquals(2, bfs.size());
+        assertTrue(dfs.containsAll(Arrays.asList(0, 1)));
+        assertTrue(bfs.containsAll(Arrays.asList(0, 1)));
+    }
+}