Discovering the Shortest Path: Dijkstra's Algorithm in JavaScript


Dijkstra's algorithm is a popular and widely used algorithm in computer science and graph theory. It is used to find the shortest path between a starting node and all other nodes in a weighted graph. In this article, we will explore Dijkstra's algorithm and implement it in JavaScript with a code snippet and detailed explanation.

Understanding Dijkstra's Algorithm:

Dijkstra's algorithm works on a weighted graph, where each edge has a non-negative weight representing the cost to move between nodes. The algorithm maintains a set of unvisited nodes and an array of distances, initialized to infinity, from the starting node to all other nodes. The starting node is set at distance 0, as it is the source of the shortest path.

Step-by-Step Explanation:

1. Create a graph and assign weights to each edge.

2. Initialize an array of 'distances' to store the shortest distance from the starting node to each node. Set the distance of the starting node to 0 and all other nodes to infinity.

3. Create a priority queue to keep track of the unvisited nodes and their distances. Initially, add the starting node to the queue.

4. While the priority queue is not empty, do the following:

   a. Dequeue the node with the minimum distance from the priority queue.

   b. For each neighbor of the dequeued node, calculate the total distance from the starting node to that neighbor through the dequeued node. If this distance is smaller than the current recorded distance for that neighbor, update it in the 'distances' array and enqueue the neighbor to the priority queue.

5. After the algorithm finishes, the 'distances' array will contain the shortest path from the starting node to all other nodes.

JavaScript Code Snippet:

function dijkstra(graph, start) {

  const distances = {};

  const priorityQueue = new PriorityQueue();

  // Initialize distances with infinity and start node with distance 0

  for (let vertex in graph) {

    distances[vertex] = Infinity;


  distances[start] = 0;

  priorityQueue.enqueue(start, 0);

  while (!priorityQueue.isEmpty()) {

    const currentVertex = priorityQueue.dequeue().element;

    for (let neighbor in graph[currentVertex]) {

      // Calculate total distance from start to neighbor

      const totalDistance = distances[currentVertex] + graph[currentVertex][neighbor];

      if (totalDistance < distances[neighbor]) {

        // Update distance if a shorter path is found

        distances[neighbor] = totalDistance;

        priorityQueue.enqueue(neighbor, totalDistance);




  return distances;


// Example usage

const graph = {

  A: { B: 4, C: 2 },

  B: { A: 4, C: 5, D: 10 },

  C: { A: 2, B: 5, D: 7 },

  D: { B: 10, C: 7 },


const startNode = "A";

const shortestDistances = dijkstra(graph, startNode);



Dijkstra's algorithm is a powerful tool for finding the shortest path in a weighted graph. By understanding the step-by-step process and implementing it in JavaScript, you can solve a wide range of shortest path problems efficiently. Keep in mind that this algorithm assumes non-negative weights and is not suited for graphs with negative cycles.