GeeksforGeeks App
Open App
Browser
Continue

# Dijkstra’s shortest path algorithm in Java using PriorityQueue

Dijkstra’s algorithm is very similar to Prim’s algorithm for minimum spanning tree. Like Prim’s MST, we generate a SPT (shortest path tree) with a given source as a root. We maintain two sets, one set contains vertices included in the shortest-path tree, other set includes vertices not yet included in the shortest-path tree. At every step of the algorithm, we find a vertex that is in the other set (set of not yet included) and has a minimum distance from the source.

Here the only drawback with Dijkstra algorithms is that while finding the shortest path as listed as follows as we need to find the least cost path by going through the whole cost array. Not a big deal for small graphs and at the same time becomes an efficiency issue for large graphs because each time we need to run through an array while traversing. Now as we know queues can work for us so do we apply the concept of priority queues with this algorithm to erupt out some of the disadvantages and making complexity much better.

Let us now discuss the problem statement whereas in accordance with the title it seems like the sheer implementation of one of the data structures known as priority queue with involvement of algorithm analysis in it. So let us begin with the problem statement which is listed below prior to it do stress over note as the whole concept revolves around the adjacency matrix representation.

Note: Dijkstra’s shortest Path implementations like Dijkstra’s Algorithm for Adjacency Matrix Representation (With time complexity O(v2)

Problem statement

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 the graph, find the shortest paths from the source to all vertices in the given graph.

Illustration:

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

Implementation:

## Java

 `// Java Program to Implement Dijkstra's Algorithm``// Using Priority Queue` `// Importing utility classes``import` `java.util.*;` `// Main class DPQ``public` `class` `GFG {` `    ``// Member variables of this class``    ``private` `int` `dist[];``    ``private` `Set settled;``    ``private` `PriorityQueue pq;``    ``// Number of vertices``    ``private` `int` `V;``    ``List > adj;` `    ``// Constructor of this class``    ``public` `GFG(``int` `V)``    ``{` `        ``// This keyword refers to current object itself``        ``this``.V = V;``        ``dist = ``new` `int``[V];``        ``settled = ``new` `HashSet();``        ``pq = ``new` `PriorityQueue(V, ``new` `Node());``    ``}` `    ``// Method 1``    ``// 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) {` `            ``// Terminating condition check when``            ``// the priority queue is empty, return``            ``if` `(pq.isEmpty())``                ``return``;` `            ``// Removing the minimum distance node``            ``// from the priority queue``            ``int` `u = pq.remove().node;` `            ``// Adding the node whose distance is``            ``// finalized``            ``if` `(settled.contains(u))` `                ``// Continue keyword skips execution for``                ``// following check``                ``continue``;` `            ``// We don't have to call e_Neighbors(u)``            ``// if u is already present in the settled set.``            ``settled.add(u);` `            ``e_Neighbours(u);``        ``}``    ``}` `    ``// Method 2``    ``// 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]));``            ``}``        ``}``    ``}` `    ``// Main driver method``    ``public` `static` `void` `main(String arg[])``    ``{` `        ``int` `V = ``5``;``        ``int` `source = ``0``;` `        ``// Adjacency list representation of the``        ``// connected edges by declaring List class object``        ``// Declaring object of type List``        ``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 GFG(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``));` `        ``// Calculating the single source shortest path``        ``GFG dpq = ``new` `GFG(V);``        ``dpq.dijkstra(adj, source);` `        ``// Printing 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 2``// Helper class implementing Comparator interface``// Representing a node in the graph``class` `Node ``implements` `Comparator {` `    ``// Member variables of this class``    ``public` `int` `node;``    ``public` `int` `cost;` `    ``// Constructors of this class` `    ``// Constructor 1``    ``public` `Node() {}` `    ``// Constructor 2``    ``public` `Node(``int` `node, ``int` `cost)``    ``{` `        ``// This keyword refers to current instance itself``        ``this``.node = node;``        ``this``.cost = cost;``    ``}` `    ``// Method 1``    ``@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```

Time Complexity: O( V + E logV ) .

Space Complexity: O(V+ E)

My Personal Notes arrow_drop_up