# DSA12# How to implement a Graph (Adjacency List and Matrix) in JavaScript

Graph-based questions are one of the most popular asked questions in software interviews. Last year I published an introduction to graphs, explaining the different graph types and how they can be represented. You can read that article as a reminder, it will help you to understand the implementation.

In this one, we are going to learn how to implement all those graph representations in JavaScript, since the implementation can change according to the language.

Let’s start writing code

# Adjacency List

It’s a way to represent a graph by using a linked list, each node will be linked to every node adjacent to him.

In JavaScript we don’t need to create a pure linked list, we will use the built-in data structures `Set`

and `Map`

and wrap all methods inside a JS class named Graph.

## Unweight and Undirected Graph

So First we have created a class named Graph and that class has only one property named adjacencyList. Our constructor initiates the property with an empty Map. So that means our entire adjacency list graph will be represented using the Map.

Now we can add some methods inside the class.

**addNode**: this method adds a new node inside the Graph. The method receives the node we want to add and we use the built-in function set that receives two parameters, the first is the key that will be used to retrieve the value and the second is the value we want to add. Here the value is a new Set since in the introduction we have mentioned that in an adjacency list, a node should be linked to all the nodes adjacent to it so that the Set will contain all nodes adjacent to the node used as key.

**addEdge**: an edge is a path between two nodes, since we are creating an undirected graph, it means that if there is a path from node1 to node 2, there is a path from node2 to node1 as well. It’s what the function to here it retrieves the list of adjacent nodes for node1 and node2 and then adds the inverse node inside each list.

**getNeighboors**: this method returns all the adjacent nodes to a given node, only getting the value inside the graph by using the given node as the key.

**hasEdge**: this function check if there is a path from node1 to node2, to do that it retrieves all nodes adjacent to node1 and then checks if node2 exists in that list.

## Unweight and directed Graph

The difference between a directed and undirected graph is that inside a directed graph, if there is a path from node1 to node2 doesn’t mean there is a path from node2 to node1 as well, if you want you need to explicitly create that second path.

If we want to create a directed graph from the previous code implemented, we have just to edit the `addEdge`

method by removing the second path creation.

## Weighted Graph

A weighted graph is a graph in which there is a numerical number attached to the path between two adjacent nodes. That numerical number represents the distance between the nodes, it’s commonly used when we want to calculate the shortest path between two given nodes.

If we want to create a weighted graph, by using the class implemented previously we have to make some adjustments.

First, we have changed the data structure used when creating a new node, now we use a Map instead of a Set because the Map will help us to store a key and value while we only store value with Set.

Then when we create a new path between two nodes, we need to receive those two nodes and the path’s weight as well.

Finally, the node will be the key and the weight will be the value stored.

# Adjacency Matrix

It’s a way to represent a Graph by using a 2D array. The indices represent the nodes, if the value at the cell `(i,j)`

is equal to 1 which means there is a path between the node i and j otherwise it will be equal to 0.

## Unweight and Undirected Graph

We will keep the overall Graph class as a wrapper.

Since we will create a 2D array we have to know in advance the number of nodes we want to store, that's the role of the `numberNodes`

property and then we have the second which represents the array itself.

Every time a new instance of the Graph is created we have to pass the number of nodes, and then we create a new empty array assigned to the `adjacencyMatrix`

property.

Last we traverse that array by assigning to each cell a new array of size `numberNodes`

filled with zero.

PS: here we don’t need a method to add a node inside the Graph.

**addEdge**: the method receives the two nodes and then we have to set the value at the cell `adjacencyMatrix[node1][node2]`

to 1 and since it’s an undirected graph we have to do the same for the reverse direction `adjacencyMatrix[node2][node1]`

.

**hasEdge**: to check if there is a path or edge between two given nodes, first the method checks if the values received exist in the Graph and then we check if the value at `adjacencyMatrix[node1][node2]`

is equal to 1 and since it’s an undirected graph we have to check for the reverse direction as well if so we return `true`

.

**getNeighboors**: to retrieve all adjacent nodes to a given node we return the cell to the position `node`

.

**removeEdge**: to remove we first check if the given values are valid, if so we set the value at the cell `(node1, node2)`

to 0 and we have to do that for both directions since it’s an undirected Graph.

## Unweight and directed Graph

For a directed Graph, we have to update the class above by removing every section of code where we were doing the same operation for the reverse direction.

Check the code below:

## Weighted Graph

For a weighted Graph, since we have to store the numerical number that represents the distance between two nodes, we will update the class written before, and instead of storing `1`

when there is an edge or path between two nodes, we will store the distance.

Check the code below:

You may have noticed that in the code above since we now store the distance rather than `1`

while checking if a path exists, we will check if the value at `(node1,node2)`

is different to `0`

.

# Conclusion

In summary, this article has covered the implementation of graph data structures in JavaScript, specifically focusing on adjacency lists and adjacency matrix representations. We explored unweighted and undirected graphs, as well as variations such as directed and weighted graphs. By understanding these implementations, we gain the ability to solve graph-related problems and utilize graph algorithms effectively in real-world scenarios.