# Dijkstra’s shortest path algorithm in Java using PriorityQueue

Given a graph with adjacency list representation of the edges between the nodes, the task is to implement Dijkstra’s Algorithm for single source shortest path using Priority Queue in Java.

Given a graph and a source vertex in graph, find shortest paths from source to all vertices in the given graph.

``` Input : Source = 0
Output :
Vertex   Distance from Source
0                0
1                4
2                12
3                19
4                21
5                11
6                9
7                8
8                14```

We have discussed Dijkstra’s shortest Path implementations like Dijkstra’s Algorithm for Adjacency Matrix Representation (With time complexity O(v2)

Below is the Java implementation of Dijkstra’s Algorithm using Priority Queue:

 `// Java implementation of Dijkstra's Algorithm  ` `// using Priority Queue ` `import` `java.util.*; ` `public` `class` `DPQ { ` `    ``private` `int` `dist[]; ` `    ``private` `Set settled; ` `    ``private` `PriorityQueue pq; ` `    ``private` `int` `V; ``// Number of vertices ` `    ``List > adj; ` ` `  `    ``public` `DPQ(``int` `V) ` `    ``{ ` `        ``this``.V = V; ` `        ``dist = ``new` `int``[V]; ` `        ``settled = ``new` `HashSet(); ` `        ``pq = ``new` `PriorityQueue(V, ``new` `Node()); ` `    ``} ` ` `  `    ``// Function for Dijkstra's Algorithm ` `    ``public` `void` `dijkstra(List > adj, ``int` `src) ` `    ``{ ` `        ``this``.adj = adj; ` ` `  `        ``for` `(``int` `i = ``0``; i < V; i++) ` `            ``dist[i] = Integer.MAX_VALUE; ` ` `  `        ``// Add source node to the priority queue ` `        ``pq.add(``new` `Node(src, ``0``)); ` ` `  `        ``// Distance to the source is 0 ` `        ``dist[src] = ``0``; ` `        ``while` `(settled.size() != V) { ` ` `  `            ``// remove the minimum distance node  ` `            ``// from the priority queue  ` `            ``int` `u = pq.remove().node; ` ` `  `            ``// adding the node whose distance is ` `            ``// finalized ` `            ``settled.add(u); ` ` `  `            ``e_Neighbours(u); ` `        ``} ` `    ``} ` ` `  `    ``// Function to process all the neighbours  ` `    ``// of the passed node ` `    ``private` `void` `e_Neighbours(``int` `u) ` `    ``{ ` `        ``int` `edgeDistance = -``1``; ` `        ``int` `newDistance = -``1``; ` ` `  `        ``// All the neighbors of v ` `        ``for` `(``int` `i = ``0``; i < adj.get(u).size(); i++) { ` `            ``Node v = adj.get(u).get(i); ` ` `  `            ``// If current node hasn't already been processed ` `            ``if` `(!settled.contains(v.node)) { ` `                ``edgeDistance = v.cost; ` `                ``newDistance = dist[u] + edgeDistance; ` ` `  `                ``// If new distance is cheaper in cost ` `                ``if` `(newDistance < dist[v.node]) ` `                    ``dist[v.node] = newDistance; ` ` `  `                ``// Add the current node to the queue ` `                ``pq.add(``new` `Node(v.node, dist[v.node])); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String arg[]) ` `    ``{ ` `        ``int` `V = ``5``; ` `        ``int` `source = ``0``; ` ` `  `        ``// Adjacency list representation of the  ` `        ``// connected edges ` `        ``List > adj = ``new` `ArrayList >(); ` ` `  `        ``// Initialize list for every node ` `        ``for` `(``int` `i = ``0``; i < V; i++) { ` `            ``List item = ``new` `ArrayList(); ` `            ``adj.add(item); ` `        ``} ` ` `  `        ``// Inputs for the DPQ graph ` `        ``adj.get(``0``).add(``new` `Node(``1``, ``9``)); ` `        ``adj.get(``0``).add(``new` `Node(``2``, ``6``)); ` `        ``adj.get(``0``).add(``new` `Node(``3``, ``5``)); ` `        ``adj.get(``0``).add(``new` `Node(``4``, ``3``)); ` ` `  `        ``adj.get(``2``).add(``new` `Node(``1``, ``2``)); ` `        ``adj.get(``2``).add(``new` `Node(``3``, ``4``)); ` ` `  `        ``// Calculate the single source shortest path ` `        ``DPQ dpq = ``new` `DPQ(V); ` `        ``dpq.dijkstra(adj, source); ` ` `  `        ``// Print the shortest path to all the nodes ` `        ``// from the source node ` `        ``System.out.println(``"The shorted path from node :"``); ` `        ``for` `(``int` `i = ``0``; i < dpq.dist.length; i++) ` `            ``System.out.println(source + ``" to "` `+ i + ``" is "` `                               ``+ dpq.dist[i]); ` `    ``} ` `} ` ` `  `// Class to represent a node in the graph ` `class` `Node ``implements` `Comparator { ` `    ``public` `int` `node; ` `    ``public` `int` `cost; ` ` `  `    ``public` `Node() ` `    ``{ ` `    ``} ` ` `  `    ``public` `Node(``int` `node, ``int` `cost) ` `    ``{ ` `        ``this``.node = node; ` `        ``this``.cost = cost; ` `    ``} ` ` `  `    ``@Override` `    ``public` `int` `compare(Node node1, Node node2) ` `    ``{ ` `        ``if` `(node1.cost < node2.cost) ` `            ``return` `-``1``; ` `        ``if` `(node1.cost > node2.cost) ` `            ``return` `1``; ` `        ``return` `0``; ` `    ``} ` `} `

Output:

```The shorted path from node :
0 to 0 is 0
0 to 1 is 8
0 to 2 is 6
0 to 3 is 5
0 to 4 is 3
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

4

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.