added Dijkstra Algorithm in graph

Author: Amit-Verma5262

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

@@ -2,49 +2,36 @@
 
 public class DijkstraShortestPath {
 
-    /**
-     * Finds the shortest path distances from the startNode to all other nodes in a weighted graph.
-     *
-     * @param n The number of nodes in the graph.
-     * @param adjList The adjacency list where each entry contains pairs of neighboring nodes and edge weights.
-     * @param startNode The starting node for the shortest path calculation.
-     * @return An array where each index i contains the shortest distance from startNode to node i.
-     */
-    public int[] shortestPath(int n, Map<Integer, List<int[]>> adjList, int startNode) {
-        int[] distances = new int[n];
+    public int[] shortestPath(int numNodes, Map<Integer, List<int[]>> adjList, int startNode) {
+        int[] distances = new int[numNodes];
         Arrays.fill(distances, Integer.MAX_VALUE);
         distances[startNode] = 0;
 
         PriorityQueue<int[]> minHeap = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
-        minHeap.offer(new int[]{startNode, 0});
+        minHeap.offer(new int[] {startNode, 0});
 
         while (!minHeap.isEmpty()) {
             int[] current = minHeap.poll();
             int currentNode = current[0];
             int currentDistance = current[1];
 
-            // This condition prevents revisiting nodes with a longer distance
             if (currentDistance > distances[currentNode]) {
                 continue;
             }
 
-            List<int[]> neighbors = adjList.getOrDefault(currentNode, new ArrayList<>());
-            for (int[] neighbor : neighbors) {
-                int nextNode = neighbor[0];
-                int edgeWeight = neighbor[1];
-
+            for (int[] edge : adjList.getOrDefault(currentNode, Collections.emptyList())) {
+                int nextNode = edge[0];
+                int edgeWeight = edge[1];
                 int newDistance = distances[currentNode] + edgeWeight;
                 if (newDistance < distances[nextNode]) {
                     distances[nextNode] = newDistance;
-                    minHeap.offer(new int[]{nextNode, newDistance});
+                    minHeap.offer(new int[] {nextNode, newDistance});
                 }
             }
         }
-
         return distances;
     }
 }
 
-//wikipedia link for algorithm
-
-//https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#:~:text=Dijkstra's%20algorithm%20(/%CB%88da%C9%AA,and%20published%20three%20years%20later.
+// wikipedia link for algorithm
+// https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#:~:text=Dijkstra's%20algorithm%20(/%CB%88da%C9%AA,and%20published%20three%20years%20later.

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

@@ -1,8 +1,8 @@
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
-import java.util.ArrayList;
 import java.util.Map;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -19,41 +19,38 @@ public void setUp() {
     @Test
     public void testSinglePath() {
         Map<Integer, List<int[]>> adjList = new HashMap<>();
-        adjList.put(0, List.of(new int[]{1, 1}));
-        adjList.put(1, List.of(new int[]{2, 1}));
-        adjList.put(2, List.of(new int[]{3, 1}));
+        adjList.put(0, List.of(new int[] {1, 1}));
+        adjList.put(1, List.of(new int[] {2, 1}));
+        adjList.put(2, List.of(new int[] {3, 1}));
         adjList.put(3, new ArrayList<>());
 
         int[] result = dijkstra.shortestPath(4, adjList, 0);
-
         int[] expected = {0, 1, 2, 3};
-        assertArrayEquals(expected, result, "Shortest path distances should match.");
+        assertArrayEquals(expected, result, "Distances should match expected shortest path distances.");
     }
 
     @Test
     public void testDisconnectedGraph() {
         Map<Integer, List<int[]>> adjList = new HashMap<>();
-        adjList.put(0, List.of(new int[]{1, 2}));
-        adjList.put(1, List.of(new int[]{2, 2}));
+        adjList.put(0, List.of(new int[] {1, 2}));
+        adjList.put(1, List.of(new int[] {2, 2}));
         adjList.put(2, new ArrayList<>());
         adjList.put(3, new ArrayList<>());
 
         int[] result = dijkstra.shortestPath(4, adjList, 0);
-
         int[] expected = {0, 2, 4, Integer.MAX_VALUE};
-        assertArrayEquals(expected, result, "Shortest path should indicate unreachable nodes.");
+        assertArrayEquals(expected, result, "Distances should match expected shortest path distances.");
     }
 
     @Test
     public void testComplexGraph() {
         Map<Integer, List<int[]>> adjList = new HashMap<>();
-        adjList.put(0, List.of(new int[]{1, 4}, new int[]{2, 1}));
-        adjList.put(1, List.of(new int[]{3, 1}));
-        adjList.put(2, List.of(new int[]{1, 2}, new int[]{3, 5}));
+        adjList.put(0, List.of(new int[] {1, 4}, new int[] {2, 1}));
+        adjList.put(1, List.of(new int[] {3, 1}));
+        adjList.put(2, List.of(new int[] {1, 2}, new int[] {3, 5}));
         adjList.put(3, new ArrayList<>());
 
         int[] result = dijkstra.shortestPath(4, adjList, 0);
-
         int[] expected = {0, 3, 1, 4};
         assertArrayEquals(expected, result, "Distances should match expected shortest path distances.");
     }
@@ -62,15 +59,13 @@ public void testComplexGraph() {
     public void testRevisitedNodeWithHigherDistance() {
         // This graph is set up to test the condition where a node is revisited with a higher distance.
         Map<Integer, List<int[]>> adjList = new HashMap<>();
-        adjList.put(0, List.of(new int[]{1, 5}));
-        adjList.put(1, List.of(new int[]{2, 1}));
-        adjList.put(2, List.of(new int[]{0, 3}, new int[]{3, 1}));
+        adjList.put(0, List.of(new int[] {1, 5}));
+        adjList.put(1, List.of(new int[] {2, 1}));
+        adjList.put(2, List.of(new int[] {0, 3}, new int[] {3, 1}));
         adjList.put(3, new ArrayList<>());
 
         int[] result = dijkstra.shortestPath(4, adjList, 0);
-
         int[] expected = {0, 5, 6, 7};
         assertArrayEquals(expected, result, "Distances should match expected shortest path distances.");
     }
 }
-//added test cases