The Dijkstra algorithm is an algorithm used to solve the shortest path problem in a graph. This means that given a number of nodes and the edges between them as well as the “length” of the edges (referred to as “weight”), the Dijkstra algorithm is finds the shortest path from the specified start node to all other nodes. Nodes are sometimes referred to as vertices (plural of vertex) - here, we’ll call them nodes.

Description of the Algorithm

The basic principle behind the Dijkstra algorithm is to iteratively look at the node with the currently smallest distance to the source and update all not yet visited neighbors if the path to it via the current node is shorter. In more detail, this leads to the following Steps:

1. Initialize the distance to the starting node as 0 and the distances to all other nodes as infinite
2. Set all nodes to “unvisited”

3. While we haven’t visited all nodes:

   1. Find the node with currently shortest distance from the source (for the first pass, this will be the source node itself)
   2. For all nodes next to it that we haven’t visited yet, check if the currently smallest distance to that neighbor is bigger than if we were to go via the current node
   3. If it is, update the smallest distance of that neighbor to be the distance from the source to the current node plus the distance from the current node to that neighbor

In the end, the array we used to keep track of the currently shortest distance from the source to all other nodes will contain the (final) shortest distances.

Example of the Algorithm

Consider the following graph:

The steps the algorithm performs on this graph if given node 0 as a starting point, in order, are:

1. Visiting node 0
2. Updating distance of node 1 to 3
3. Updating distance of node 2 to 1
4. Visited nodes: 0
5. Currently lowest distances: [0, 3, 1, Infinite, Infinite, Infinite]

6. Visiting node 1 with current distance 1

   • Updating distance of node 3 to 5
   • Visited nodes: 0, 2
   • Currently lowest distances: [0, 3, 1, 5, Infinite, Infinite]

7. Visiting node 3 with current distance 3

   • Updating distance of node 4 to 4
   • Visited nodes: 0, 1, 2
   • Currently lowest distances: [0, 3, 1, 5, 4, Infinite]

8. Visiting node 4 with current distance 4

   • Updating distance of node 5 to 5
   • Visited nodes: 0, 1, 2, 4
   • Currently lowest distances: [0, 3, 1, 5, 4, 5]

9. Visiting node 5 with current distance 5

   • No distances to update
   • Visited nodes: 0, 1, 2, 3, 4
   • Currently lowest distances: [0, 3, 1, 5, 4, 5]

10. Visiting node 5 with current distance 5

    • No distances to update
    • Visited nodes: 0, 1, 2, 3, 4, 5

All nodes visited Final lowest distances: [0, 3, 1, 5, 4, 5]

Runtime of the Algorithm

The runtime complexity of Dijkstra depends on how it is implemented. If a min-heap is used to determine the next node to visit, and adjacency is implemented using adjacency lists, the runtime is O(|E| + |V|log|V|) (|V| = number of Nodes, |E| = number of Edges). If a we simply search all distances to find the node with the lowest distance in each step, and use a matrix to look up whether two nodes are adjacent, the runtime complexity increases to O(|V|^2).

Space of the Algorithm

The space complexity of Dijkstra depends on how it is implemented as well and is equal to the runtime complexity.