{ "componentChunkName": "component---src-templates-post-js", "path": "/python-graphs/", "result": {"data":{"markdownRemark":{"html":"

Graphs in Python

\n

In this post, we're going to implement a graph data structure from scratch in Python.

\n

We'll create two different graph representations:

\n\n

Along the way, we'll explore nodes, edges, weights, directed graphs, undirected graphs, and some of the design decisions involved in representing relationships between objects.

\n

PREREQUISITES

\n\n

Goals

\n\n

Graphs

\n

Graphs are among the most useful data structures in computer science.

\n

They are used to represent relationships between objects.

\n

For example, a social network can be represented as a graph where people are nodes and friendships are edges.

\n
graph LR\n Alice --- Bob\n Alice --- Emma\n Bob --- John\n Emma --- John
\n

A road network can be represented as a graph where cities are nodes and roads are edges.

\n
graph LR\n Delhi ---|212 km| Agra\n Agra ---|238 km| Jaipur\n Delhi ---|281 km| Jaipur
\n

Graphs are also used in:

\n\n

A graph consists of two primary components:

\n\n

Let's start with an edge.

\n

The Edge Class

\n

An edge represents a connection between two nodes.

\n

For our implementation, an edge will contain three pieces of information:

\n\n
class Edge:\n\n    def __init__(self, from_node, to_node, weight):\n        self.from_node = from_node\n        self.to_node = to_node\n        self.weight = weight
\n

Let's create an edge.

\n
>>> edge = Edge(0, 1, 5)
\n

This represents an edge from node 0 to node 1 with a weight of 5.

\n
graph LR\n A((0)) -->|5| B((1))
\n

The meaning of the weight depends on the problem we're trying to solve.

\n

It could represent:

\n\n

We can inspect the edge directly.

\n
>>> edge.from_node\n0\n\n>>> edge.to_node\n1\n\n>>> edge.weight\n5
\n

Our edge is ready.

\n

Now we need something to connect.

\n

The Node Class

\n

A node represents an object in our graph.

\n

Each node will have:

\n\n
class Node:\n\n    def __init__(self, index, label=None):\n        self.index = index\n        self.edges = {}\n        self.label = label
\n

Let's create a node.

\n
>>> node = Node(0, label=\"Delhi\")\n\n>>> node.index\n0\n\n>>> node.label\n'Delhi'
\n

The edges dictionary will store the outgoing connections from this node.

\n
>>> node.edges\n{}
\n

We use a dictionary where the key is the index of the neighbouring node and the value is the corresponding Edge object.

\n

For example:

\n
{\n    1: Edge(0, 1, 5),\n    2: Edge(0, 2, 8)\n}
\n

Using a dictionary allows us to quickly locate an edge when we already know the target node.

\n

Adding an Edge to a Node

\n

Let's add a method for creating an outgoing edge.

\n
def add_edge(self, target, weight):\n    self.edges[target] = Edge(\n        self.index,\n        target,\n        weight\n    )
\n

The method creates an Edge object and stores it using the target node as the dictionary key.

\n
>>> node.add_edge(1, 5)
\n

Our node now represents the following structure:

\n
graph LR\n A((0)) -->|5| B((1))
\n

We can inspect the edge.

\n
>>> node.edges\n{1: <__main__.Edge object at 0x...>}
\n

That output isn't particularly helpful.

\n

Let's add a representation to the Edge class.

\n
class Edge:\n\n    def __init__(self, from_node, to_node, weight):\n        self.from_node = from_node\n        self.to_node = to_node\n        self.weight = weight\n\n    def __repr__(self):\n        return (\n            f\"Edge({self.from_node}, \"\n            f\"{self.to_node}, \"\n            f\"weight={self.weight})\"\n        )
\n

Now our edge is easier to understand.

\n
>>> node.edges\n{1: Edge(0, 1, weight=5)}
\n

Much better.

\n

Removing an Edge

\n

Removing an edge from a node is simply a matter of deleting it from the dictionary.

\n
def remove_edge(self, target):\n    del self.edges[target]
\n

For example:

\n
>>> node.remove_edge(1)\n\n>>> node.edges\n{}
\n

If the edge doesn't exist, Python will raise a KeyError.

\n

If we want the method to silently ignore missing edges, we could instead use:

\n
def remove_edge(self, target):\n    self.edges.pop(target, None)
\n

For now, we'll keep the stricter version. Attempting to remove an edge that doesn't exist is probably a programming error, and raising an exception makes that problem visible.

\n

Getting an Edge

\n

We can retrieve a particular edge using its neighbouring node.

\n
def get_edge(self, neighbor):\n    return self.edges.get(neighbor)
\n

Let's add an edge and retrieve it.

\n
>>> node.add_edge(1, 5)\n\n>>> node.get_edge(1)\nEdge(0, 1, weight=5)
\n

If the connection doesn't exist, the method returns None.

\n
>>> node.get_edge(7)\nNone
\n

Getting All Edges

\n

Sometimes we want all the outgoing edges from a node.

\n
def get_edges(self):\n    return self.edges.values()
\n

Let's add a couple of connections.

\n
>>> node.add_edge(1, 5)\n>>> node.add_edge(2, 8)\n\n>>> list(node.get_edges())\n[Edge(0, 1, weight=5), Edge(0, 2, weight=8)]
\n

Notice that we're returning a dictionary values view rather than creating another list.

\n

The caller can still create a list if required:

\n
list(node.get_edges())
\n

However, we avoid creating an unnecessary copy when the caller only wants to iterate over the edges.

\n

Counting Edges

\n

The number of outgoing edges is simply the size of our dictionary.

\n
def num_edges(self):\n    return len(self.edges)
\n

Now:

\n
>>> node.num_edges()\n2
\n

We could also expose this through Python's Data Model.

\n
def __len__(self):\n    return len(self.edges)
\n

This lets us write:

\n
>>> len(node)\n2
\n

Both approaches are valid. The second one makes our object feel more like a native Python collection.

\n

Getting the Neighbours

\n

A neighbour is any node connected to the current node by an outgoing edge.

\n
def get_neighbors(self):\n    neighbors = set()\n\n    for edge in self.edges.values():\n        neighbors.add(edge.to_node)\n\n    return neighbors
\n

For our current node:

\n
>>> node.get_neighbors()\n{1, 2}
\n

The structure looks like this:

\n
graph LR\n A((0)) -->|5| B((1))\n A -->|8| C((2))
\n

We return a set because every neighbour should appear only once.

\n

Since our edges are already stored in a dictionary keyed by the target node, this method could also be written more simply:

\n
def get_neighbors(self):\n    return set(self.edges)
\n

This is one of the benefits of selecting an appropriate internal representation. Sometimes a good representation makes several operations almost trivial.

\n

Sorting the Edges

\n

We can also return the edges sorted by the index of their target node.

\n
def get_sorted_edge_list(self):\n    result = []\n\n    for neighbor in sorted(self.edges):\n        result.append(self.edges[neighbor])\n\n    return result
\n

For example:

\n
>>> node = Node(0)\n\n>>> node.add_edge(5, 10)\n>>> node.add_edge(2, 7)\n>>> node.add_edge(3, 4)\n\n>>> node.get_sorted_edge_list()\n[\n    Edge(0, 2, weight=7),\n    Edge(0, 3, weight=4),\n    Edge(0, 5, weight=10)\n]
\n

The edges are sorted by the target node, not by their weights.

\n

If we wanted to sort by weight instead, we could write:

\n
def get_edges_sorted_by_weight(self):\n    return sorted(\n        self.edges.values(),\n        key=lambda edge: edge.weight\n    )
\n

Now that we have nodes and edges, let's build a graph.

\n

The Graph Class

\n

Our first graph implementation will use an adjacency list.

\n
class Graph:\n\n    def __init__(self, num_nodes, undirected=False):\n        self.num_nodes = num_nodes\n        self.undirected = undirected\n        self.nodes = [\n            Node(index)\n            for index in range(num_nodes)\n        ]
\n

Creating a graph with five nodes:

\n
>>> graph = Graph(5)
\n

produces:

\n
graph LR\n A((0))\n B((1))\n C((2))\n D((3))\n E((4))
\n

There are five nodes, but there are no connections yet.

\n

Every node is assigned an index based on its position in the nodes list.

\n
>>> graph.nodes[0].index\n0\n\n>>> graph.nodes[4].index\n4
\n

Validating Node Indices

\n

Before adding or retrieving an edge, we need to make sure both node indices exist.

\n
def _verify_node_indices(self, from_node, to_node):\n\n    if from_node < 0 or from_node >= self.num_nodes:\n        raise IndexError(\"Source node is out of range\")\n\n    if to_node < 0 or to_node >= self.num_nodes:\n        raise IndexError(\"Target node is out of range\")
\n

Now invalid indices produce a useful error.

\n
>>> graph.get_edge(0, 10)\nIndexError: Target node is out of range
\n

The leading underscore in _verify_node_indices indicates that this is an internal helper method.

\n

It doesn't make the method private, but it tells other developers that the method is intended for internal use.

\n

Adding Edges

\n

Let's add a method for connecting two nodes.

\n
def insert_edge(self, from_node, to_node, weight):\n    self._verify_node_indices(from_node, to_node)\n\n    self.nodes[from_node].add_edge(\n        to_node,\n        weight\n    )\n\n    if self.undirected:\n        self.nodes[to_node].add_edge(\n            from_node,\n            weight\n        )
\n

For a directed graph, the edge is added only to the source node.

\n
>>> graph.insert_edge(0, 1, 5)
\n
graph LR\n A((0)) -->|5| B((1))
\n

The arrow is important.

\n

Node 0 connects to node 1, but node 1 doesn't automatically connect back to node 0.

\n
>>> graph.get_edge(0, 1)\nEdge(0, 1, weight=5)\n\n>>> graph.get_edge(1, 0)\nNone
\n

Directed Graphs

\n

A directed graph contains edges with a specific direction.

\n

Consider a dependency system.

\n
graph LR\n A[Compile] --> B[Test]\n B --> C[Deploy]
\n

Testing depends on compilation, and deployment depends on testing.

\n

These relationships aren't necessarily reversible.

\n

A directed flight route provides another example.

\n
graph LR\n A[City A] --> B[City B]
\n

A flight from City A to City B doesn't automatically mean there is a corresponding flight from City B to City A.

\n

Undirected Graphs

\n

In an undirected graph, an edge represents a connection in both directions.

\n

We can create one by passing undirected=True.

\n
>>> network = Graph(3, undirected=True)\n\n>>> network.insert_edge(0, 1, 5)
\n

Internally, the graph creates two directed edges:

\n
0 -> 1\n1 -> 0
\n

Together, they represent one undirected relationship.

\n
graph LR\n A((0)) ---|5| B((1))
\n

Now both lookups succeed.

\n
>>> network.get_edge(0, 1)\nEdge(0, 1, weight=5)\n\n>>> network.get_edge(1, 0)\nEdge(1, 0, weight=5)
\n

Building a Weighted Graph

\n

Let's create a more interesting graph.

\n
>>> graph = Graph(5)\n\n>>> graph.insert_edge(0, 1, 5)\n>>> graph.insert_edge(0, 2, 3)\n>>> graph.insert_edge(1, 3, 1)\n>>> graph.insert_edge(2, 3, 6)\n>>> graph.insert_edge(2, 4, 8)\n>>> graph.insert_edge(3, 4, 2)
\n

The result looks like this:

\n
graph LR\n A((0)) -->|5| B((1))\n A -->|3| C((2))\n B -->|1| D((3))\n C -->|6| D\n C -->|8| E((4))\n D -->|2| E
\n

The same graph can be described as an adjacency list.

\n
0 -> (1, 5), (2, 3)\n1 -> (3, 1)\n2 -> (3, 6), (4, 8)\n3 -> (4, 2)\n4 ->
\n

Each row tells us which nodes can be reached directly from a particular node.

\n

Getting an Edge from the Graph

\n

Our graph delegates edge retrieval to the corresponding node.

\n
def get_edge(self, from_node, to_node):\n    self._verify_node_indices(from_node, to_node)\n    return self.nodes[from_node].get_edge(to_node)
\n

Now:

\n
>>> graph.get_edge(0, 2)\nEdge(0, 2, weight=3)
\n

If the edge doesn't exist:

\n
>>> graph.get_edge(4, 0)\nNone
\n

Checking Whether an Edge Exists

\n

We can build a convenience method on top of get_edge.

\n
def is_edge(self, from_node, to_node):\n    return self.get_edge(from_node, to_node) is not None
\n

Now:

\n
>>> graph.is_edge(0, 2)\nTrue\n\n>>> graph.is_edge(4, 0)\nFalse
\n

Notice that we didn't duplicate our lookup logic.

\n

Whenever possible, it's usually better to build new functionality using methods we've already tested.

\n

Creating an Edge List

\n

Sometimes we need a single list containing every edge in the graph.

\n
def make_edge_list(self):\n    edges = []\n\n    for node in self.nodes:\n        for edge in node.get_edges():\n            edges.append(edge)\n\n    return edges
\n

Let's try it.

\n
>>> graph.make_edge_list()\n[\n    Edge(0, 1, weight=5),\n    Edge(0, 2, weight=3),\n    Edge(1, 3, weight=1),\n    Edge(2, 3, weight=6),\n    Edge(2, 4, weight=8),\n    Edge(3, 4, weight=2)\n]
\n

This representation is particularly useful for algorithms that need to examine every edge.

\n

Removing an Edge

\n

Removing an edge is similar to inserting one.

\n
def remove_edge(self, from_node, to_node):\n    self._verify_node_indices(from_node, to_node)\n\n    self.nodes[from_node].remove_edge(to_node)\n\n    if self.undirected:\n        self.nodes[to_node].remove_edge(from_node)
\n

For a directed graph, only one edge is removed.

\n
>>> graph.remove_edge(0, 1)\n\n>>> graph.is_edge(0, 1)\nFalse
\n

For an undirected graph, we remove both internal edges.

\n
>>> network = Graph(3, undirected=True)\n>>> network.insert_edge(0, 1, 5)\n\n>>> network.remove_edge(0, 1)\n\n>>> network.is_edge(0, 1)\nFalse\n\n>>> network.is_edge(1, 0)\nFalse
\n

Adding a Node

\n

Let's allow the graph to grow after it has been created.

\n
def insert_node(self, label=None):\n    node = Node(self.num_nodes, label=label)\n\n    self.nodes.append(node)\n    self.num_nodes += 1\n\n    return node
\n

Now:

\n
>>> graph = Graph(3)\n\n>>> graph.insert_node(label=\"New Node\")\nNew Node
\n

Our graph now contains four nodes.

\n
>>> graph.num_nodes\n4\n\n>>> graph.nodes[3].label\n'New Node'
\n

Let's add a useful representation to Node.

\n
def __repr__(self):\n    if self.label is not None:\n        return str(self.label)\n\n    return f\"Node({self.index})\"
\n

Now labelled nodes display their labels, while unlabelled nodes display their indices.

\n
>>> graph.nodes[0]\nNode(0)\n\n>>> graph.nodes[3]\nNew Node
\n

Finding Incoming Neighbours

\n

The edges stored inside a node tell us about its outgoing neighbours.

\n

For example:

\n
graph LR\n A((0)) --> B((1))
\n

Node 1 is an outgoing neighbour of node 0.

\n

But what if we want to know which nodes point to node 1?

\n

These are called its incoming neighbours.

\n
def get_in_neighbors(self, target):\n\n    if target < 0 or target >= self.num_nodes:\n        raise IndexError(\"Target node is out of range\")\n\n    neighbors = set()\n\n    for node in self.nodes:\n        if target in node.edges:\n            neighbors.add(node)\n\n    return neighbors
\n

Consider this graph:

\n
graph LR\n A((0)) --> D((3))\n B((1)) --> D\n C((2)) --> D
\n

Calling:

\n
>>> graph.get_in_neighbors(3)
\n

would return nodes 0, 1, and 2.

\n

The adjacency list makes outgoing-neighbour lookups easy. Finding incoming neighbours requires us to inspect the outgoing edges of every node.

\n

This is an important trade-off in data structure design. A representation that makes one operation fast may make another operation more expensive.

\n

Copying a Graph

\n

Let's create a copy of our graph.

\n
def make_copy(self):\n    copied_graph = Graph(\n        self.num_nodes,\n        undirected=self.undirected\n    )\n\n    for node in self.nodes:\n        copied_graph.nodes[node.index].label = node.label\n\n    for edge in self.make_edge_list():\n        copied_graph.insert_edge(\n            edge.from_node,\n            edge.to_node,\n            edge.weight\n        )\n\n    return copied_graph
\n

Now:

\n
>>> copied_graph = graph.make_copy()
\n

The copied graph has its own nodes and edges.

\n
>>> copied_graph is graph\nFalse\n\n>>> copied_graph.nodes[0] is graph.nodes[0]\nFalse
\n

Changing the copy doesn't change the original.

\n
>>> copied_graph.remove_edge(0, 2)\n\n>>> copied_graph.is_edge(0, 2)\nFalse\n\n>>> graph.is_edge(0, 2)\nTrue
\n

Implementing the Python Data Model

\n

We can add a few special methods to make our graph easier to use.

\n

Implementing __len__

\n

The length of the graph is the number of nodes.

\n
def __len__(self):\n    return self.num_nodes
\n

Now:

\n
>>> len(graph)\n5
\n

Implementing __getitem__

\n

Let's make nodes accessible using square brackets.

\n
def __getitem__(self, index):\n\n    if index < 0 or index >= self.num_nodes:\n        raise IndexError(\"Node index is out of range\")\n\n    return self.nodes[index]
\n

Now:

\n
>>> graph[0]\nNode(0)
\n

Implementing __iter__

\n

We can also make the graph iterable.

\n
def __iter__(self):\n    yield from self.nodes
\n

This allows us to loop over the nodes.

\n
>>> for node in graph:\n...     print(node)
\n

With these methods, our custom graph begins to behave like a native Python collection.

\n

The Complete Adjacency List Implementation

\n

Here's our complete implementation so far.

\n
class Edge:\n\n    def __init__(self, from_node, to_node, weight):\n        self.from_node = from_node\n        self.to_node = to_node\n        self.weight = weight\n\n    def __repr__(self):\n        return (\n            f\"Edge({self.from_node}, \"\n            f\"{self.to_node}, \"\n            f\"weight={self.weight})\"\n        )\n\n\nclass Node:\n\n    def __init__(self, index, label=None):\n        self.index = index\n        self.edges = {}\n        self.label = label\n\n    def __repr__(self):\n        if self.label is not None:\n            return str(self.label)\n\n        return f\"Node({self.index})\"\n\n    def __len__(self):\n        return len(self.edges)\n\n    def add_edge(self, target, weight):\n        self.edges[target] = Edge(\n            self.index,\n            target,\n            weight\n        )\n\n    def remove_edge(self, target):\n        del self.edges[target]\n\n    def num_edges(self):\n        return len(self.edges)\n\n    def get_edge(self, neighbor):\n        return self.edges.get(neighbor)\n\n    def get_edges(self):\n        return self.edges.values()\n\n    def get_sorted_edge_list(self):\n        result = []\n\n        for neighbor in sorted(self.edges):\n            result.append(self.edges[neighbor])\n\n        return result\n\n    def get_neighbors(self):\n        return set(self.edges)\n\n\nclass Graph:\n\n    def __init__(self, num_nodes, undirected=False):\n        self.num_nodes = num_nodes\n        self.undirected = undirected\n        self.nodes = [\n            Node(index)\n            for index in range(num_nodes)\n        ]\n\n    def __len__(self):\n        return self.num_nodes\n\n    def __getitem__(self, index):\n        if index < 0 or index >= self.num_nodes:\n            raise IndexError(\"Node index is out of range\")\n\n        return self.nodes[index]\n\n    def __iter__(self):\n        yield from self.nodes\n\n    def _verify_node_indices(self, from_node, to_node):\n        if from_node < 0 or from_node >= self.num_nodes:\n            raise IndexError(\"Source node is out of range\")\n\n        if to_node < 0 or to_node >= self.num_nodes:\n            raise IndexError(\"Target node is out of range\")\n\n    def get_edge(self, from_node, to_node):\n        self._verify_node_indices(from_node, to_node)\n        return self.nodes[from_node].get_edge(to_node)\n\n    def is_edge(self, from_node, to_node):\n        return self.get_edge(from_node, to_node) is not None\n\n    def make_edge_list(self):\n        edges = []\n\n        for node in self.nodes:\n            for edge in node.get_edges():\n                edges.append(edge)\n\n        return edges\n\n    def insert_edge(self, from_node, to_node, weight):\n        self._verify_node_indices(from_node, to_node)\n\n        self.nodes[from_node].add_edge(\n            to_node,\n            weight\n        )\n\n        if self.undirected:\n            self.nodes[to_node].add_edge(\n                from_node,\n                weight\n            )\n\n    def remove_edge(self, from_node, to_node):\n        self._verify_node_indices(from_node, to_node)\n\n        self.nodes[from_node].remove_edge(to_node)\n\n        if self.undirected:\n            self.nodes[to_node].remove_edge(from_node)\n\n    def insert_node(self, label=None):\n        node = Node(self.num_nodes, label=label)\n\n        self.nodes.append(node)\n        self.num_nodes += 1\n\n        return node\n\n    def make_copy(self):\n        copied_graph = Graph(\n            self.num_nodes,\n            undirected=self.undirected\n        )\n\n        for node in self.nodes:\n            copied_graph.nodes[node.index].label = node.label\n\n        for edge in self.make_edge_list():\n            copied_graph.insert_edge(\n                edge.from_node,\n                edge.to_node,\n                edge.weight\n            )\n\n        return copied_graph\n\n    def get_in_neighbors(self, target):\n        if target < 0 or target >= self.num_nodes:\n            raise IndexError(\"Target node is out of range\")\n\n        neighbors = set()\n\n        for node in self.nodes:\n            if target in node.edges:\n                neighbors.add(node)\n\n        return neighbors
\n

Adjacency Matrices

\n

The adjacency list isn't the only way to represent a graph.

\n

Another popular representation is an adjacency matrix.

\n

An adjacency matrix is a two-dimensional structure where rows represent source nodes and columns represent target nodes.

\n

Consider this graph:

\n
graph LR\n A((0)) -->|5| B((1))\n A -->|3| C((2))\n B -->|1| D((3))\n C -->|6| D
\n

Its adjacency matrix looks like this:

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
From / To0123
00530
10001
20006
30000
\n

For example:

\n
matrix[0][1] = 5
\n

means that there is an edge from node 0 to node 1 with a weight of 5.

\n

Similarly:

\n
matrix[1][0] = 0
\n

means that we haven't stored an edge from node 1 to node 0.

\n

The GraphMatrix Class

\n

Let's implement it.

\n
class GraphMatrix:\n\n    def __init__(self, num_nodes, undirected=False):\n        self.num_nodes = num_nodes\n        self.undirected = undirected\n\n        self.connections = [\n            [0.0] * num_nodes\n            for _ in range(num_nodes)\n        ]
\n

Creating a graph with four nodes:

\n
>>> matrix = GraphMatrix(4)
\n

initializes:

\n
[\n    [0.0, 0.0, 0.0, 0.0],\n    [0.0, 0.0, 0.0, 0.0],\n    [0.0, 0.0, 0.0, 0.0],\n    [0.0, 0.0, 0.0, 0.0]\n]
\n

Every possible pair of nodes receives a position in the matrix.

\n

Setting an Edge

\n
def set_edge(self, from_node, to_node, weight):\n    self._verify_node_indices(from_node, to_node)\n\n    self.connections[from_node][to_node] = weight\n\n    if self.undirected:\n        self.connections[to_node][from_node] = weight
\n

Let's add an edge.

\n
>>> matrix.set_edge(0, 1, 5)
\n

The matrix becomes:

\n
[\n    [0.0, 5,   0.0, 0.0],\n    [0.0, 0.0, 0.0, 0.0],\n    [0.0, 0.0, 0.0, 0.0],\n    [0.0, 0.0, 0.0, 0.0]\n]
\n

Getting an Edge

\n
def get_edge(self, from_node, to_node):\n    self._verify_node_indices(from_node, to_node)\n    return self.connections[from_node][to_node]
\n

Now:

\n
>>> matrix.get_edge(0, 1)\n5\n\n>>> matrix.get_edge(1, 0)\n0.0
\n

Edge lookup is straightforward because we know exactly where the value is stored.

\n

Removing an Edge

\n

We can remove an edge by resetting its matrix entry.

\n
def remove_edge(self, from_node, to_node):\n    self.set_edge(from_node, to_node, 0.0)
\n

If the graph is undirected, set_edge automatically clears both directions.

\n

Complete Adjacency Matrix Implementation

\n
class GraphMatrix:\n\n    def __init__(self, num_nodes, undirected=False):\n        self.num_nodes = num_nodes\n        self.undirected = undirected\n\n        self.connections = [\n            [0.0] * num_nodes\n            for _ in range(num_nodes)\n        ]\n\n    def __len__(self):\n        return self.num_nodes\n\n    def _verify_node_indices(self, from_node, to_node):\n        if from_node < 0 or from_node >= self.num_nodes:\n            raise IndexError(\"Source node is out of range\")\n\n        if to_node < 0 or to_node >= self.num_nodes:\n            raise IndexError(\"Target node is out of range\")\n\n    def get_edge(self, from_node, to_node):\n        self._verify_node_indices(from_node, to_node)\n        return self.connections[from_node][to_node]\n\n    def set_edge(self, from_node, to_node, weight):\n        self._verify_node_indices(from_node, to_node)\n\n        self.connections[from_node][to_node] = weight\n\n        if self.undirected:\n            self.connections[to_node][from_node] = weight\n\n    def remove_edge(self, from_node, to_node):\n        self.set_edge(from_node, to_node, 0.0)
\n

Adjacency List vs Adjacency Matrix

\n

We now have two representations of the same data structure.

\n

Adjacency List

\n
0 -> 1, 2\n1 -> 3\n2 -> 3\n3 ->
\n

The adjacency list stores only the edges that actually exist.

\n

It is usually a good choice when the graph contains relatively few connections compared with the total number of possible connections.

\n

Adjacency Matrix

\n
0 5 3 0\n0 0 0 1\n0 0 0 6\n0 0 0 0
\n

The adjacency matrix reserves space for every possible connection.

\n

It makes checking a particular node pair straightforward, but it may reserve a lot of unused space.

\n

For a graph with n nodes, the matrix contains:

\n
n × n
\n

entries even when the graph contains only a handful of edges.

\n

A Note About Zero-Weight Edges

\n

Our matrix uses 0.0 to represent the absence of an edge.

\n

This creates an important limitation.

\n

What if an actual edge has a weight of zero?

\n
matrix.set_edge(0, 1, 0.0)
\n

We can no longer distinguish between:

\n\n

One possible solution is to use None instead of 0.0.

\n
self.connections = [\n    [None] * num_nodes\n    for _ in range(num_nodes)\n]
\n

Now:

\n
>>> graph.get_edge(0, 1)\nNone
\n

means:

\n
No edge exists
\n

while:

\n
>>> graph.set_edge(0, 1, 0.0)\n\n>>> graph.get_edge(0, 1)\n0.0
\n

represents a valid edge whose weight happens to be zero.

\n

Small implementation details like this often determine which problems a data structure can solve correctly.

\n

Adjacency Lists vs Adjacency Matrices

\n

We now have two completely different implementations that represent exactly the same graph.

\n

Adjacency List

\n
graph LR\n A((0)) -->|5| B((1))\n A -->|3| C((2))\n B -->|1| D((3))\n C -->|6| D
\n

Internally:

\n
0 -> (1, 5), (2, 3)\n1 -> (3, 1)\n2 -> (3, 6)\n3 ->
\n

Only existing edges consume memory.

\n

An adjacency list is generally a good choice when the graph contains relatively few edges compared with the total number of possible connections.

\n

Such graphs are often called sparse graphs.

\n
graph LR\n A((0))\n B((1))\n C((2))\n D((3))\n E((4))\n\n A --> B\n C --> D
\n

Most real-world graphs are sparse.

\n

Examples include:

\n\n

Adjacency Matrix

\n

The same graph can be represented as:

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
0123
00530
10001
20006
30000
\n

The matrix stores space for every possible connection.

\n

This makes edge lookups extremely simple:

\n
>>> matrix[0][2]\n3
\n

However, it also means we may allocate memory for many edges that don't exist.

\n

Consider a graph with:

\n
10,000 nodes
\n

An adjacency matrix would require:

\n
10,000 × 10,000\n=\n100,000,000 entries
\n

even if the graph only contains a handful of connections.

\n

Time Complexity

\n

Let's compare the two representations.

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
OperationAdjacency ListAdjacency Matrix
Add EdgeO(1)O(1)
Remove EdgeO(1)O(1)
Edge LookupO(1)*O(1)
Iterate NeighborsO(k)O(n)
Memory UsageO(V + E)O(V²)
\n

Where:

\n\n

The adjacency list is usually preferred for large sparse graphs.

\n

The adjacency matrix becomes attractive when:

\n\n

Real-World Examples

\n

Social Networks

\n
graph LR\n Alice --- Bob\n Alice --- Emma\n Emma --- John\n Bob --- John
\n

Nodes:

\n
Users
\n

Edges:

\n
Friendships
\n

Road Networks

\n
graph LR\n Delhi ---|220 km| Agra\n Agra ---|240 km| Jaipur\n Delhi ---|280 km| Jaipur
\n

Nodes:

\n
Cities
\n

Edges:

\n
Roads
\n

Weights:

\n
Distance
\n

Computer Networks

\n
graph LR\n Router --> Switch\n Switch --> Server\n Switch --> Workstation
\n

Nodes:

\n
Devices
\n

Edges:

\n
Network Connections
\n

Weights:

\n
Latency\nBandwidth\nCost
\n

Package Dependencies

\n
graph TD\n App --> Requests\n App --> NumPy\n Requests --> urllib3
\n

Nodes:

\n
Packages
\n

Edges:

\n
Dependencies
\n

This structure appears in:

\n\n

Common Graph Algorithms

\n

Now that we have a graph representation, we can begin exploring graph algorithms.

\n

Some of the most useful algorithms include:

\n

Breadth First Search (BFS)

\n

Explores a graph level by level.

\n
graph TD\n A((A))\n B((B))\n C((C))\n D((D))\n E((E))\n\n A --> B\n A --> C\n B --> D\n C --> E
\n

Used for:

\n\n

Depth First Search (DFS)

\n

Explores one path completely before backtracking.

\n
graph TD\n A((A))\n B((B))\n C((C))\n D((D))\n\n A --> B\n B --> C\n C --> D
\n

Used for:

\n\n

Dijkstra's Algorithm

\n

Finds the shortest path in a weighted graph.

\n
graph LR\n A((A)) -->|4| B((B))\n A -->|1| C((C))\n C -->|2| B
\n

We'll eventually combine graphs with our Heap implementation to build this algorithm from scratch.

\n

Minimum Spanning Trees

\n

Find the minimum cost required to connect all nodes.

\n

Popular algorithms include:

\n\n

Topological Sorting

\n

Used to order tasks with dependencies.

\n
graph TD\n Compile --> Test\n Test --> Package\n Package --> Deploy
\n

Oh Yeah, It's All Coming Together

\n

At this point we've implemented:

\n
Edge\nNode\nGraph\nGraphMatrix
\n

Along the way we learned about:

\n
Directed Graphs\nUndirected Graphs\nWeighted Graphs\nAdjacency Lists\nAdjacency Matrices\nNeighbors\nEdge Lookups\nGraph Traversal
\n

Just like our Linked List, Tree, and Heap implementations, the real lesson wasn't simply building a graph.

\n

The real lesson was understanding how different representations can model relationships between objects.

\n

Once you understand graphs, you'll start seeing them everywhere.

\n
Road Maps\nSocial Networks\nRecommendation Engines\nComputer Networks\nBuild Systems\nPackage Managers\nSearch Engines\nCompilers\nOperating Systems
\n

Graphs are one of the most versatile data structures in computer science.

\n

And now we have our own implementation.

\n

That's it folks!

","excerpt":"Graphs in Python In this post, we're going to implement a graph data structure from scratch in Python. We'll create two different graph…","fields":{"slug":"/python-graphs/"},"frontmatter":{"title":"Graphs in Python","date":"April 17, 2026","tags":["Python"],"categories":["Highlight","Python"],"description":"Graphs in Python","comments_off":false,"thumbnail":{"childImageSharp":{"fixed":{"base64":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAACXBIWXMAAAsSAAALEgHS3X78AAADb0lEQVQ4y22V3W9UVRTF51/xwSd8IeFBTXzSB0yQSCDESBUJUWPAGIuxktYQMYaYgoUEYwlNMZRQpRYxQ2vrx9AyNtJpobRDa2f6NdMvSi2axgbmnL3P/Zl779zOTOlNTu7kzD7rrL322vvGWH88PC98hws8r/Qurc1joicWbToXBt4YFOrOCnP3NQhwrvKAH9MSt5y6aDHWlYF6mwM2tFi2veYYGJVy7jw2ihWPviHD7mph+yFh+d/ipWUsywDDzWze0RIvMJkXrvdaP5zz7cK+T5Sm9gK3xyzZnDA5K0WZQhmi1GMRcgQ4t6QMjRuONwpbXlUyOUvLdeXFt5WxGaH+gvBxQ5SuV6FzALhR7KZ2Q/NPlqGM0NplWfhbeLiq/Pqn4e645egZYX+dUDBaUbDod8xnpkV2/6wqOw4rO99XuvsMt4YNh74Qdn4Qptj2i2FmwbL2SIn3Cld/D9P2MfwVAG6s4EDacmtEGJuyZHLCuR+UmtPC/RXL/lrlzVqfsbD7Q8cLbznmH2ilbRYeKEsriqrj61ahI6kBg1cOC9UnfQZa1MrxeaPw1UXhr2lD01VD6p7Q1v2YkayQX1REPWJ7qpUDnwqLy5aX31MO1CmZvOXgMcPlzjAldZHojolZof03w3BWOHNJGJ0STjRZtr2udNwUYvXfCjWnLR3JQhA0NS9cSxSYnrfkFgQjbt20XX3CM7uUy52WzqTw1HbHtYQvj/LOceHuuPgahi4fmRC+uRIWIdFv+a7LsnWv0jMQWmR6TgJNPzrl20pQp4HWq/9FF4bvmJ+JFnVt/lHYulcYHFOyeWHfUWEka/GzeP4Nn7khkzN0JC1HTgqTc6G+vnahbcp86P+x9sgxkQ/T7r1tGc5a/rhjSKSEmgahPy2kszZoz2erlHiPDTXW0vCIRYYO2ydkWn/B8vQOJXnH8n234UbKBtU+1+Z3iSMzY4P2DFKNCBVxYuVdEhl8el65FLdB2x08pjxXpcwuCZ81CnuOKMMZQ3/aBLHRmQBns+EwkPbNLCRShvhNw5VuCcaVEY+C8VhdU1p/Fk6ctzjPhSUtMvQhnxhfXzZbtuxygddKg7Q0ntQ5qmqFl95Vlh+WZmYUFdvY4Isrjp5BW2TsBQ5wrjwLj9FJIXVPy7T31u+s6OWN47xUMG/DZ+LJM9H2/zJlun01rfO9AAAAAElFTkSuQmCC","width":150,"height":150,"src":"/static/69f2d8d1b40d14d0b146d5519b185068/92ab1/graphs.png","srcSet":"/static/69f2d8d1b40d14d0b146d5519b185068/92ab1/graphs.png 1x,\n/static/69f2d8d1b40d14d0b146d5519b185068/668a7/graphs.png 1.5x,\n/static/69f2d8d1b40d14d0b146d5519b185068/56e34/graphs.png 2x"}}}}}},"pageContext":{"slug":"/python-graphs/","previous":{"id":"caa5e25b-9f7c-56c9-8144-d0888aed46dd","frontmatter":{"title":"Heap in Python","tags":["Python"],"categories":["Highlight","Python"],"template":"post"},"fields":{"slug":"/python-heap/"}},"next":null}}, "staticQueryHashes": []}