Representing Graphs in Data Structures

Graph Basics

Contributed by: Ruchi Nayyar

Graphs are fundamental data structures widely used to model relationships between objects. 

Whether it’s social networks, transportation systems, or computer networks, graphs are powerful tools for representing connections and dependencies. 

In computer science, understanding how to represent graphs efficiently is crucial for solving complex problems effectively. 

In this blog post, we will explore the representation of graphs in data structures and explain the various representations of graphs with detailed examples that will help you understand the concept. 

What Is A Graph?

A graph is a fundamental construct in computer science. It serves as an abstract representation of interconnected objects. 

It comprises two main components: vertices, which represent the objects, and edges, which denote the links between them.

A graph is a pair of sets (V, E), where V represents the vertices and E the edges connecting these vertices.

For instance, consider the following graph:

Graph Basics:

• V = {a, b, c, d, e}
• E = {ab, ac, bd, cd, de}

In this graph, the vertices are {a, b, c, d, e}, and the edges are {ab, ac, bd, cd, de}. Each edge connects two vertices, indicating a relationship between them.

Understanding the concept of a graph is crucial for various applications. It forms the cornerstone of graph representation in data structures, enabling efficient manipulation and analysis of interconnected data.

Don’t miss out on the opportunity to enroll in the ‘Free Data Structures in C Course‘ and build a strong foundation in programming.

Also

Read “What is Data Structure: Need, Types & Classification” to enhance your comprehension of data structuring fundamentals and their significance!

Major Graph Terminology

Understanding the major terminology associated with graphs is essential for navigating through graph-related concepts effectively:

• Vertex- Also known as a node, a vertex represents an entity within a graph. It can represent various things, such as cities in a transportation network or users in a social media platform.

• Edge- An edge represents a graph’s connection or relationship between two vertices. It can be directional (from one vertex to another) or undirected (connecting two vertices without a specific direction).

• Adjacency- Adjacency refers to the relationship between vertices directly connected by an edge. For example, if vertex A is connected to vertex B by an edge, then A and B are considered adjacent.

• Path- A path in a graph is a sequence of vertices connected by edges. It represents a route or journey from one vertex to another. Paths can be simple (no repeated vertices) or cyclic (repeating vertices).

• Directed Graph- Also known as a digraph, a directed graph is a type of graph in which edges have a direction. This means that the relationship between vertices is one-way, indicating a specific direction for traversal. 

Understanding these fundamental concepts lays the foundation for exploring more advanced graph representation techniques, algorithms, and applications.

Don’t miss out on the insights presented in “Application of Graph Theory in 2024” to understand graph theory’s impact on today’s world.

Methods Of Graph Operations

1. Depth First Search Traversal (DFS)

DFS is a graph traversal algorithm that systematically explores all vertices by going as deep as possible along each branch before backtracking.

It starts from an arbitrary vertex, explores as far as possible along each branch before backtracking, and continues until all vertices are visited. DFS utilizes a stack data structure to keep track of vertices.

2. Breadth First Search Traversal (BFS)

BFS is a graph traversal algorithm that systematically explores all vertices at the current level before moving to the next level. 

It starts from an arbitrary vertex, explores all adjacent vertices at the current level, and then moves to the next level. BFS utilizes a queue data structure to keep track of vertices.

3. Detecting Cycles

Detecting cycles in a graph involves identifying if there are any loops or cycles present within the graph structure. 

This is crucial in various applications to prevent infinite loops or unintended behavior. Techniques like depth-first or breadth-first search can detect cycles by keeping track of visited vertices and identifying back edges during traversal.

4. Topological Sorting

Topological sorting is a graph algorithm used to linearly order the vertices of a directed acyclic graph (DAG) based on their dependencies. 

It ensures that for every directed edge from vertex u to vertex v, u comes before v in the ordering. Topological sorting is commonly used in scheduling tasks, resolving dependencies in build systems, and optimizing workflow execution.

5. Minimum Spanning Tree (MST)

A Minimum Spanning Tree (MST) is a subset of edges of a connected, undirected graph that connects all vertices with the minimum possible total edge weight. 

Finding a graph’s MST is essential in various applications, such as network design, clustering, and resource allocation. Common algorithms for finding MST include Kruskal’s algorithm and Prim’s algorithm.

Representation Of Graphs

Graphs can be represented in different ways, each offering unique advantages and trade-offs in terms of space complexity, time complexity, and ease of implementation. 

Two different ways of representing a graph in data structure are the Adjacency Matrix and Adjacency List.

1. Adjacency Matrix

An adjacency matrix is a 2D array in which each cell represents the presence or absence of an edge between two vertices. If an edge exists from vertex i to vertex j, the cell (i, j) contains a non-zero value (often 1); otherwise, it includes 0.

Advantages

• Straightforward Implementation- The adjacency matrix is intuitive and easy to implement. It directly translates the graph structure into a matrix.

• Efficient for Dense Graphs- In graphs where the number of edges is close to the maximum possible (dense graphs), adjacency matrices are efficient as they use less memory than lists.

• Constant-Time Access- This method determines if an edge between two vertices is constant-time (O(1)), making it efficient for certain operations like checking for connectivity.

Disadvantages

• Memory Consumption- Adjacency matrices consume more memory, especially for sparse graphs, where many entries in the matrix are zero.

• Inefficiency for Sparse Graphs- Adjacency matrices are inefficient in graphs with few edges (sparse graphs) because they waste memory storing zero values.

• Inflexible for Dynamic Graphs- Modifying the graph structure, such as adding or removing edges, can be inefficient as it requires resizing the matrix.

Example
Consider the following graph with vertices A, B, C, and D:

A  B  C  D

 A  0  1  1  0

 B  1  0  0  1

 C  1  0  0  1

 D  0  1  1  0

In this adjacency matrix, a value of 1 indicates the presence of an edge between the corresponding vertices, while 0 indicates no edge. Lets understand better with code

Code Example

# Implementation of Adjacency Matrix

class Graph:

    def __init__(self, num_vertices):

        self.num_vertices = num_vertices

        self.adj_matrix = [[0] * num_vertices for _ in range(num_vertices)]

    def add_edge(self, from_vertex, to_vertex):

        self.adj_matrix[from_vertex][to_vertex] = 1

        self.adj_matrix[to_vertex][from_vertex] = 1

    def display(self):

        for row in self.adj_matrix:

            print(row)

# Create a graph with 4 vertices

graph = Graph(4)

# Add edges

graph.add_edge(0, 1)

graph.add_edge(0, 2)

graph.add_edge(1, 3)

graph.add_edge(2, 3)

# Display the adjacency matrix

print("Adjacency Matrix:")

graph.display()

Output : Adjacency Matrix

[0, 1, 1, 0]

[1, 0, 0, 1]

[1, 0, 0, 1]

[0, 1, 1, 0]

Adjacency Matrix Code Explanation

The code defines a graph class that represents a graph using an adjacency matrix. It initializes with the number of vertices and creates a 2D array to store edges. 

The add_edge method updates the matrix to indicate the presence of an edge between vertices. The display method prints the adjacency matrix. 

The example creates a graph with 4 vertices, adds edges, and displays the adjacency matrix. The output shows the matrix representing the graph structure.

Apart from python, If you’re seeking insights into how data structures operate in C, delve into “Data Structures using C | What are the Data Structure in C and How it works?“

2. Adjacency List

An adjacency list is a collection of linked lists or arrays, each representing a vertex in the graph. Each element in the list/array stores the adjacent vertices of the corresponding vertex.

Advantages

• Memory Efficiency for Sparse Graphs- Adjacency lists are memory-efficient for sparse graphs since they only store information about existing edges.

• Efficient for Dynamic Graphs- Adjacency lists are suitable for dynamic graphs where edges are frequently added or removed, as they can be easily modified without resizing.

• Efficient Traversal- Traversal of adjacent vertices is efficient as each vertex maintains a list of its adjacent vertices.

Disadvantages

• Complex Implementation- Implementing adjacency lists requires managing linked lists or arrays for each vertex, which can be more complicated than an adjacency matrix.

• Potential Additional Memory Usage- Depending on the implementation, adjacency lists may require additional memory for storing pointers or references to adjacent vertices.

Example

Consider the same graph with vertices A, B, C, and D:

A -> [B, C]

B -> [A, D]

C -> [A, D]

D -> [B, C]

Each vertex is associated with a list/array containing its adjacent vertices in this adjacency list representation. For example, vertex A is adjacent to vertices B and C, as the list indicates [B, C]. Lets understand this better with the code

Code Example

# Implementation of Adjacency List

class Graph:

    def __init__(self):

        self.adj_list = {}

    def add_edge(self, from_vertex, to_vertex):

        if from_vertex not in self.adj_list:

            self.adj_list[from_vertex] = []

        if to_vertex not in self.adj_list:

            self.adj_list[to_vertex] = []

        self.adj_list[from_vertex].append(to_vertex)

        self.adj_list[to_vertex].append(from_vertex)

    def display(self):

        for vertex, neighbors in self.adj_list.items():

            print(f"{vertex} -> {neighbors}")

# Create a graph

graph = Graph()

# Add edges

graph.add_edge('A', 'B')

graph.add_edge('A', 'C')

graph.add_edge('B', 'D')

graph.add_edge('C', 'D')

# Display the adjacency list

print("Adjacency List:")

graph.display()

Output: Adjacency List

A -> ['B', 'C']

B -> ['A', 'D']

C -> ['A', 'D']

D -> ['B', 'C']

Adjacency List Code Explanation

The code defines a graph class that represents a graph using an adjacency list. It initializes an empty dictionary to store vertices and their adjacent vertices. 

The add_edge method adds vertices and their neighbors to the adjacency list. The display method prints the adjacency list. 

The example creates a graph, adds edges, and displays the adjacency list. The output shows each vertex and its adjacent vertices.

Understanding the various representations of graphs in data structures is crucial for efficiently storing and traversing graphs, enabling the implementation of various algorithms and analyses.

You can also Checkout our blog on ‘Data Structures and Algorithms in Java‘ to become a Java expert in Data Structures and Algorithms

Types of Graphs

Graphs can be classified into various types based on their characteristics and properties. Two common types are Directed Graphs (Digraphs) and Undirected Graphs.

1. Directed Graph (Digraph)

In a directed graph, edges have a direction associated with them. This means that the relationship between vertices is one-way, indicating a specific direction for traversal.

Characteristics

• Directional Edges- Each edge in the graph has a direction from one vertex to another, indicating a specific relationship between them.

• Asymmetric Relationships- The relationship between vertices in a directed graph is asymmetric, meaning that the presence of an edge from vertex A to vertex B does not necessarily imply the existence of an edge from B to A.

• Directed Connectivity- Directed graphs can represent various relationships with specific directional dependencies.

Applications

• Network Routing- Directed graphs are used in network routing algorithms to model the flow of data or resources through a network with specific directional paths.

• Dependency Analysis- In software engineering, directed graphs are utilized for dependency analysis, where dependencies between components or modules are represented with directional edges.

• Social Networks- Directed graphs can model social networks, where edges represent inherently directional relationships such as following or subscribing.

Code Example

import networkx as nx

import matplotlib.pyplot as plt

# Create a directed graph

G = nx.DiGraph()

# Add edges to the graph

G.add_edge('A', 'B')

G.add_edge('B', 'C')

G.add_edge('C', 'A')

# Draw the graph

nx.draw(G, with_labels=True, arrows=True)

plt.show()

Output

Visualization of the directed graph with vertices A, B, and C connected by directed edges indicating the direction of relationships.

Explanation

The code creates a directed graph with three nodes (A, B, and C) and three edges forming a cycle:

An edge from A to B.
An edge from B to C.
An edge from C to A.

The graph is then visualized with arrows indicating the direction of the edges, and node labels are displayed. The resulting graph is a simple directed cycle.

Join our Post Graduate Program in Data Science and Business Analytics and learn the essentials of data structure, including representing graphs. 
– Get a Dual Certificate from UT Austin & Great Lakes
– Learn anytime, anywhere
– Weekly online mentorship by experts
– Dedicated Program Support

2. Undirected Graph

In an undirected graph, edges do not have a direction associated with them. This means that the relationship between vertices is bidirectional, allowing traversal in both directions.

Characteristics

• Undirected Edges- Edges in the graph do not have a specific direction associated with them, allowing traversal in both directions between connected vertices.

• Symmetric Relationships- The relationship between vertices in an undirected graph is symmetric, meaning that if there is an edge between vertices A and B, there is also an edge between vertices B and A.

• Bidirectional Connectivity- Undirected graphs represent bidirectional relationships where the order of vertices does not matter.

Applications

• Social Networks- Undirected graphs are commonly used to model social networks, where friendships or connections between individuals are inherently bidirectional.

• Transportation Networks- Undirected graphs can represent transportation networks, where edges represent connections between locations or nodes without specifying a direction of travel.

• Wireless Sensor Networks- Undirected graphs are utilized in wireless sensor networks to model bidirectional communication links between sensor nodes.

Code Example

import networkx as nx

import matplotlib.pyplot as plt

# Create an undirected graph

G = nx.Graph()

# Add edges to the graph

G.add_edge('A', 'B')

G.add_edge('B', 'C')

G.add_edge('C', 'A')

# Draw the graph

nx.draw(G, with_labels=True)

plt.show()

Output

Explanation

The code creates an undirected graph with three nodes (A, B, and C) and three edges forming a cycle:

An edge between A and B.
An edge between B and C.
An edge between C and A.

The graph is visualized with node labels displayed. Since it is an undirected graph, the edges do not have arrows indicating direction, representing a simple cycle connecting the three nodes.

Don’t miss out on “Data Structures For Beginners” – the perfect starting point for understanding the core concepts of data organization.

Conclusion

Understanding the various methods of representing graphs in data structures is essential for effective problem-solving in fields like data science and business analytics. 

Just as graphs are powerful tools for modelling relationships between objects, mastering their representation allows for efficient manipulation and analysis of interconnected data. 

With the Great Learning Post Graduate Program in Data Science and Business Analytics, offering dual certification from UT Austin & Great Lakes, learners gain the necessary skills and knowledge to tackle complex graph-related challenges. 

Through any time, anywhere learning and weekly online mentorship by experts, coupled with dedicated program support, participants can confidently navigate the intricate world of graph representation, paving the way for success in their professional endeavors.

FAQs