Related Articles
Dijkstra’s shortest path algorithm in Java using PriorityQueue
• Difficulty Level : Medium
• Last Updated : 25 Apr, 2019

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
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up