What is Graph Data Structure?

A graph in data structure is a way to show how things are connected. Think of it like a
map of roads connecting different cities. In a graph, the cities are called "nodes" or
"vertices," and the roads are called "edges." Graphs help us understand how things are
linked together and how they interact.

A graph is made up of nodes and edges. Nodes represent objects, and edges represent
the connections between these objects.

For example, in a social network, people are nodes, and their friendships are edges.

Types of Graph Data Structure with Examples

Graphs can be categorized based on their characteristics and properties:

1. Directed Graph
In a directed graph, edges have a direction, meaning they go from one node to another
in a specific way.

Example:

Think of a Twitter network where one person follows another. If Alice follows Bob, there
is an edge from Alice to Bob but not necessarily from Bob to Alice.
2. Undirected Graph
In an undirected graph, edges do not have a direction. They simply connect two nodes
without any particular order.

Example:

Think of a Facebook friendship where if Alice is friends with Bob, then Bob is also friends
with Alice. The edge goes both w

Example:

Think of a Facebook friendship where if Alice is friends with Bob, then Bob is also friends
with Alice. The edge goes both ways.
3. Weighted Graph
In a weighted graph, edges have weights or costs associated with them. These weights
can represent distances, costs, or any other metric.

Example:

A road map where the weights on the edges represent the distance between cities.

4. Unweighted Graph
In an unweighted graph, all edges have the same weight, typically considered as 1.
Example:

A simple social network where each friendship has the same importance.

Representations of Graph Data Structure

Graphs can be represented in several ways. The three most common methods are
adjacency matrix, adjacency list, and edge list.

1. Adjacency Matrix
An adjacency matrix is a 2D array used to represent a graph. Each cell in the matrix
indicates whether an edge exists between a pair of vertices. If an edge exists, the cell
contains a value (typically 1 for unweighted graphs or the weight of the edge for
weighted graphs); otherwise, it contains 0.

Example:

Consider a graph with 4 vertices (A, B, C, and D) and the following edges: A-B, A-C, B-
D, and C-D.

Adjacency Matrix:

ABCD

A0110

B1001

C1001

D0110

Graph:
2. Adjacency List
An adjacency list is an array of lists. The array's indices represent the vertices, and each
element in the array is a list of vertices adjacent to the vertex at that index.

Example:

Consider the same graph with 4 vertices (A, B, C, and D) and the following edges: A-B,
A-C, B-D, and C-D.

Adjacency List:

A: B, C

B: A, D

C: A, D

D: B, C

Graph:
Graph Traversal Algorithms
Graph traversal algorithms are used to visit all the vertices and edges in a graph. The
two most common traversal methods are Depth-First Search (DFS) and Breadth-First
Search (BFS). Each method has its own algorithm and applications.

1. Depth-First Search (DFS)

Algorithm:

 Start at the root (or any arbitrary node) and mark it as visited.

 Explore each adjacent node recursively that has not been visited yet.

 Repeat the process until all nodes are visited.

Steps:

 Initialize a stack and push the starting node onto the stack.

 While the stack is not empty:

 Pop a node from the stack.

 If the node has not been visited:

 Mark the node as visited.

 Push all adjacent unvisited nodes onto the stack.

Example:

Consider the following graph:

DFS Traversal from A:

 Start at A.

 Visit A, push B and C to the stack.

 Pop C, visit C, push E to the stack.

 Pop E, visit E.

 Pop B, visit B, push D to the stack.

 Pop D, visit D.

Traversal Order: A, C, E, B, D

2. Breadth-First Search (BFS)

Algorithm:

 Start at the root (or any arbitrary node) and mark it as visited.

 Explore each adjacent node level by level.

 Repeat the process until all nodes are visited.

Steps:

 Initialize a queue and enqueue the starting node.

 While the queue is not empty:

 Dequeue a node from the queue.

 If the node has not been visited:

 Mark the node as visited.

 Enqueue all adjacent unvisited nodes.

Example:

Consider the same graph:

BFS Traversal from A:

 Start at A.

 Visit A, enqueue B and C.

 Dequeue B, visit B, enqueue D.

 Dequeue C, visit C, enqueue E.

 Dequeue D, visit D.

 Dequeue E, visit E.

Traversal Order: A, B, C, D, E

Shortest Path Algorithms

Shortest path algorithms are used to find the shortest path from a source node to other
nodes in a graph. Here are three common shortest path algorithms:

1. Dijkstra's Algorithm
 Initialize distances: Set the distance to the source node to 0 and all other nodes
to infinity.

 Set the source node as current.

 For the current node, consider all its unvisited neighbors and calculate their
tentative distances through the current node.

 Compare the newly calculated tentative distance to the current assigned value
and assign the smaller one.

 Once all neighbors of the current node are considered, mark the current node as
visited.
  If the destination node has been visited, the algorithm has finished. If not, select
the unvisited node with the smallest tentative distance as the new "current node"
and repeat the process.

2. Bellman-Ford Algorithm
 Initialize distances: Set the distance to the source node to 0 and all other nodes
to infinity.

 For each edge, update the distance to the destination node if the distance to the
source node plus the edge's weight is less than the current distance to the
destination node.

 Repeat step 2 for all edges |V| - 1 times, where |V| is the number of vertices.

 Check for negative-weight cycles: If a distance can still be updated, then a

negative-weight cycle exists.

3. Floyd-Warshall Algorithm
 Create a 2D array dist and initialize it with the distances between every pair of
vertices. Set the distance from each vertex to itself to 0.

 For each pair of vertices (i, j), check if a vertex k exists such that the path from i
to j through k is shorter than the direct path from i to j. If it is, update dist[i][j].

 Repeat for all vertices.

Minimum Spanning Tree Algorithms

Minimum Spanning Tree (MST) algorithms are used to find a subset of edges in a
weighted graph that connects all vertices with the minimum possible total edge weight,
and without any cycles. The two most common MST algorithms are Kruskal's Algorithm
and Prim's Algorithm.

1. Kruskal's Algorithm
 Sort all edges in the graph in non-decreasing order of their weights.

 Initialize an empty set for the MST.

 For each edge in the sorted list:

 If the edge does not form a cycle with the edges already in the MST, add it to the
MST.

 Use a union-find data structure to keep track of which vertices are in which
components.

 Repeat until the MST contains V−1 edges, where V is the number of vertices.

2. Prim's Algorithm
 Initialize a set for the MST and a priority queue to store the edges.
  Start with an arbitrary node and add all its edges to the priority queue.

 While the MST does not include all vertices:

 Extract the edge with the minimum weight from the priority queue.

 If the edge connects a new vertex, add it to the MST.

 Add all edges from the new vertex to the priority queue.

 Repeat until all vertices are included in the MST.

Uses of Graph Data Structure (Applications)

Following are the main uses and applications of graph data structure:

Application Explanation Example

Representing user interactions and Facebook, LinkedIn,

Social Networks
connections. Twitter

Computer Optimizing data transfer and Internet routers and

Networks network structure. switches

Ranking web pages based on

Web Page Ranking Google PageRank
importance.

Finding shortest paths and

Transportation GPS navigation systems
optimizing travel routes.

Planning and optimizing task

Scheduling Gantt charts, PERT charts
execution order.

Modeling protein interactions and Protein-protein interaction

Biology
genetic networks. networks

Game Designing game levels, AI, and Pathfinding algorithms in

Development player interactions. game AI

Modeling and analyzing electrical Circuit design software like

Electrical Circuits
circuits. SPICE

Dependency Managing software project Package managers like

Resolution dependencies. npm, pip, Maven

Difference Between Tree and Graph Data Structure

The following is a comparison highlighting the key differences between tree and graph
data structures:

Feature Tree Graph

Definition A tree is a hierarchical data A graph is a collection of nodes
structure with a root node and (vertices) connected by edges,
child nodes forming a parent- representing relationships between
child relationship. the nodes.

Structure Hierarchical (parent-child Network-like (arbitrary connections

relationship) between nodes)

Root Node Has a single root node Does not necessarily have a root
node

Path There is exactly one path There can be multiple paths

between any two nodes. between any two nodes.

Cycles Trees do not contain cycles Graphs can contain cycles (cyclic)
(acyclic). or be acyclic.

Connectivity Trees are connected (all nodes Graphs can be connected or

are reachable from the root). disconnected.

Parent-Child Each node (except the root) has Nodes can have multiple parents.
Relationship exactly one parent.

Leaf Nodes Nodes with no children are called Graphs do not have the concept of
leaf nodes. leaf nodes.

Types Binary Tree, AVL Tree, B-Tree, Directed Graph, Undirected Graph,
etc. Weighted Graph, etc.

Usage Used to represent hierarchical Used to represent network

data, such as file systems, structures, such as social networks,
organization structures, and XML computer networks, and
documents. transportation systems.

Degree In a binary tree, each node has a Nodes in a graph can have any
maximum degree of 2. number of edges.

Traversal In-order, Pre-order, Post-order, Depth-First Search (DFS), Breadth-

Methods Level-order First Search (BFS)

Example Family Tree, Binary Search Tree Road Network, Social Network

Applications Efficient searching, sorting, and Network analysis, shortest path

hierarchical data storage algorithms, and connectivity checks