Graph Data Structure

Welcome to this in-depth guide on the concept of graphs in computer science. Whether you're a complete novice or an advanced learner looking to refine your understanding, this tutorial will guide you through the core concepts, representations, and practical applications of graphs, ensuring a robust understanding of this fundamental concept.

Introduction to Graphs

A graph is a data structure that consists of a set of nodes (also called vertices) and a set of edges that connect these nodes. Graphs are used to represent pairwise relationships between objects. In a graph, nodes can represent any type of entities such as people, cities, web pages, or even abstract concepts, while edges represent the relationships or connections between these entities.

Graphs are used to model a wide variety of real-world situations, from social networks (like Facebook, LinkedIn) to computer networks (like the internet), from biological systems (like protein-protein interaction networks) to transportation networks (like air traffic).

Components of a Graph

Graphs are primarily defined by two components:

  • Vertices (Nodes): The entities in a graph. Each vertex can represent an object or a piece of data.
  • Edges (Links): The connections between the vertices. An edge can represent a relationship or a pathway between two vertices.

Let's visualize this with a simple graph:

Graph G:

    A - B - D
    |   |   |
    C   E - F

Vertices: A, B, C, D, E, F
Edges: AB, AC, BD, BE, DF

Types of Graphs

Graphs can be classified into various types based on their properties:

  • Undirected Graphs: A graph where edges have no direction. The edges indicate a two-way relationship, in that each edge can be traversed in both directions.
  • Directed Graphs (Digraphs): A graph where edges have directions. Here, if an edge is directed from node A to node B, you can only travel from A to B and not from B to A.
  • Weighted Graphs: A graph where edges have weights associated with them. These weights can represent distances, costs, or any measurable attribute corresponding to the edge.
  • Unweighted Graphs: A graph where edges do not have weights. They only represent a connection between vertices.

Graph Representations

Graphs can be represented in computer memory in the following ways:

  • Adjacency Matrix: A 2D array where each cell [i][j] represents the presence or absence of an edge between the ith and jth vertex. Suitable for dense graphs.
  • Adjacency List: An array of lists. The size of the array is equal to the number of vertices. An entry array[i] represents the list of vertices adjacent to the ith vertex. Suitable for sparse graphs.
Graph Representations by Example

Graph:


       A
      / \
     B - C
    / \   \
   D - E - F

1. Adjacency Matrix Representation

In an adjacency matrix, each cell [i][j] in a 2D array represents the presence (1) or absence (0) of an edge between the ith and jth vertex. For our graph:

  • Vertices: A, B, C, D, E, F (indexed as A=0, B=1, C=2, D=3, E=4, F=5)
  • Matrix Size: 6x6 (since we have 6 vertices)
    A B C D E F
  A 0 1 1 0 0 0
  B 1 0 0 1 1 0
  C 1 0 0 0 0 1
  D 0 1 0 0 1 0
  E 0 1 0 1 0 1
  F 0 0 1 0 1 0

2. Adjacency List Representation

An adjacency list uses a dictionary where each vertex is a key, and the corresponding value is a list of edges (source, destination) adjacent to the key vertex. For our graph:

A: [(A, B), (A, C)]
B: [(B, A), (B, D), (B, E)]
C: [(C, A), (C, F)]
D: [(D, B), (D, E)]
E: [(E, B), (E, D), (E, F)]
F: [(F, C), (F, E)]

3. Adjacency List Representation (if graph has some weight)


	       A
	      / \
	    1/	 \2
	    /  2  \
	   B ----- C
	  / \       \
	3/  2\      4\
        /     \       \
       D ----- E ----- F
          2       3

In an adjacency list representation with weights, we use a dictionary where each vertex is a key, and the corresponding value is a list of weighted edges (source, destination, weight) adjacent to the key vertex. For our graph:

A: [(A, B, 1), (A, C, 2)]
B: [(B, A, 1), (B, D, 3), (B, E, 2),(B, C, 2)]
C: [(C, A, 2), (C, F, 4),(C, B, 2)]
D: [(D, B, 3), (D, E, 2)]
E: [(E, B, 2), (E, D, 2), (E, F, 3)]
F: [(F, C, 4), (F, E, 3)]

Comparison

  • Adjacency Matrix:
    • Pros: Directly shows if a connection exists between two vertices.
    • Cons: Consumes more space, particularly in sparse graphs. Slower to check connections.
  • Adjacency List:
    • Pros: More efficient space usage for sparse graphs. Faster traversal of edges.
    • Cons: Less direct when checking for a specific edge.

These representations highlight how different graph structures can be more or less efficient depending on the graph's characteristics and the operations performed on it.

Implementing Graphs in Code

Implementation of a graph structure can vary based on its intended use case and the chosen programming language. Here, we present implementations in Java, C++, Python, and JavaScript for a basic graph structure using adjacency lists. 


       A
      / \
     B - C
    / \   \
   D - E - F



import java.util.*;

class Node {
    char id;

    public Node(char id) {
        this.id = id;
    }
}

class Edge {
    Node source;
    Node destination;
    
    /* 
    * we can use here int weight; if we work for weighted graph
    * so in case if weighted graph we have three fields:
    * 1.source, 2.destination and 3.weight.
    * but, we are currently going with only two 
    * fields source and destination.
    */

    public Edge(Node source, Node destination) {
        this.source = source;
        this.destination = destination;
    }
}

public class Graph {

    private Map<Node, List<Edge>> adjList;

    public Graph(int vertices) {
        adjList = new HashMap<>();
        for (char c = 'A'; c < 'A' + vertices; c++) {
            adjList.put(new Node(c), new LinkedList<>());
        }
    }

    public void addEdge(Node source, Node destination) {
        adjList.get(source).add(new Edge(source, destination));
        // For undirected graph, add the reverse edge
        adjList.get(destination).add(new Edge(destination, source));
    }

    public void printGraph() {
        for (Node node : adjList.keySet()) {
            System.out.print("Vertex " + node.id + ": ");
            for (Edge edge : adjList.get(node)) {
                System.out.print(edge.destination.id + " ");
            }
            System.out.println();
        }
    }

    public List<Node> getNeighbors(Node node) {
        List<Node> neighbors = new ArrayList<>();
        for (Edge edge : adjList.get(node)) {
            neighbors.add(edge.destination);
        }
        return neighbors;
    }

    public static void main(String[] args) {
        Graph g = new Graph(6); // Create a graph with 6 vertices

        // Adding edges based on the given graph
        g.addEdge(new Node('A'), new Node('B')); // A - B
        g.addEdge(new Node('A'), new Node('C')); // A - C
        g.addEdge(new Node('B'), new Node('C')); // B - C
        g.addEdge(new Node('B'), new Node('D')); // B - D
        g.addEdge(new Node('B'), new Node('E')); // B - E
        g.addEdge(new Node('C'), new Node('F')); // C - F
        g.addEdge(new Node('D'), new Node('E')); // D - E
        g.addEdge(new Node('E'), new Node('F')); // E - F

        g.printGraph(); // Print the graph
    }
}



#include <iostream>
#include <list>
#include <vector>

class Node {
public:
    char id;
    Node(char _id) : id(_id) {}
};

class Edge {
public:
    Node* source;
    Node* destination;
    Edge(Node* _source, Node* _destination) : source(_source), destination(_destination) {}
};

class Graph {
    int numVertices;
    std::vector<std::list<Edge>> adjLists;

public:
    Graph(int vertices) : numVertices(vertices), adjLists(vertices) {}

    // Function to add an edge from src to dest
    void addEdge(Node* src, Node* dest) {
        adjLists[src->id - 'A'].push_back(Edge(src, dest));
        // For an undirected graph, add the reverse edge as well
        adjLists[dest->id - 'A'].push_back(Edge(dest, src));
    }

    // Function to print the graph
    void printGraph() {
        for (int i = 0; i < numVertices; i++) {
            std::cout << "Vertex " << char('A' + i) << ": ";
            for (Edge e : adjLists[i]) {
                std::cout << e.destination->id << " ";
            }
            std::cout << "\n";
        }
    }
    
    // Function to get neighbors of a node
    std::list getNeighbors(Node* node) {
        return adjLists[node->id - 'A'];
    }
    
};

int main() {
    Graph g(6); // Create a graph with 6 vertices

    // Adding edges based on the given graph
    g.addEdge(new Node('A'), new Node('B')); // A - B
    g.addEdge(new Node('A'), new Node('C')); // A - C
    g.addEdge(new Node('B'), new Node('C')); // B - C
    g.addEdge(new Node('B'), new Node('D')); // B - D
    g.addEdge(new Node('B'), new Node('E')); // B - E
    g.addEdge(new Node('C'), new Node('F')); // C - F
    g.addEdge(new Node('D'), new Node('E')); // D - E
    g.addEdge(new Node('E'), new Node('F')); // E - F

    g.printGraph(); // Print the graph
    return 0;
}


class Node:
    def __init__(self, _id):
        self.id = _id

class Edge:
    def __init__(self, _source, _destination):
        self.source = _source
        self.destination = _destination

class Graph:
    def __init__(self, num_vertices):
        # Initialize the graph with num_vertices vertices
        self.adj_list = {Node(chr(i + ord('A'))): [] for i in range(num_vertices)}

    def add_edge(self, src, dest):
        # Add an edge from src to dest
        # Since this is an undirected graph, add the reverse edge as well
        self.adj_list[src].append(Edge(src, dest))
        self.adj_list[dest].append(Edge(dest, src))

    def print_graph(self):
        # Print the adjacency list of each vertex
        for key in self.adj_list:
            print(f"Vertex {key.id}: {[edge.destination.id for edge in self.adj_list[key]]}")

    def get_neighbors(self, node):
        # Return a list of neighbors of the given node
        return [edge.destination for edge in self.adj_list[node]]

# Create a graph with 6 vertices (A to F)
g = Graph(6)

# Adding edges based on the given graph
g.add_edge(Node('A'), Node('B')) # A - B
g.add_edge(Node('A'), Node('C')) # A - C
g.add_edge(Node('B'), Node('C')) # B - C
g.add_edge(Node('B'), Node('D')) # B - D
g.add_edge(Node('B'), Node('E')) # B - E
g.add_edge(Node('C'), Node('F')) # C - F
g.add_edge(Node('D'), Node('E')) # D - E
g.add_edge(Node('E'), Node('F')) # E - F

g.print_graph() # Print the graph


class Graph {
    constructor(numVertices) {
        this.adjList = new Map();
        // Initialize the adjacency list
        for (let i = 0; i < numVertices; i++) {
            this.adjList.set(String.fromCharCode(65 + i), []);
        }
    }

    addEdge(src, dest) {
        // Add an edge from src to dest
        // Since this is an undirected graph, also add the edge from dest to src
        this.adjList.get(src).push(dest);
        this.adjList.get(dest).push(src);
    }

    printGraph() {
        // Print the adjacency list for each vertex
        for (let [key, value] of this.adjList) {
            console.log(`Vertex ${key}: ${value.join(', ')}`);
        }
    }

    getNeighbors(node) {
        // Return an array of neighbors of the given node
        return this.adjList.get(node);
    }
}

// Create a graph with 6 vertices (A to F)
const g = new Graph(6);

// Adding edges based on the given graph
g.addEdge('A', 'B'); // A - B
g.addEdge('A', 'C'); // A - C
g.addEdge('B', 'C'); // B - C
g.addEdge('B', 'D'); // B - D
g.addEdge('B', 'E'); // B - E
g.addEdge('C', 'F'); // C - F
g.addEdge('D', 'E'); // D - E
g.addEdge('E', 'F'); // E - F

g.printGraph(); // Print the graph

Graph: Concept and Important Algorithms

1. Basics of Graph Data Structure
2. Breadth-First Search (BFS) in Graph
3. Depth-First Search (DFS) in Graph 
4. Topological Sort in Graph
5. Union-Find Algorithm in Graph
6. Prim's Algorithm in Graph 
7. Dijkstra's Algorithm in Graph
8. Kruskal's Algorithm in Graph
Related categories:

Comments

Post a Comment

Popular Posts on Code Katha

Java Interview Questions for 10 Years Experience

Image
Welcome to the comprehensive guide on "Java Interview Questions for 10 Years Experience." Java has been one of the most popular programming languages for decades, and its widespread adoption means that the demand for skilled Java developers has never been higher. If you are someone who has been working with Java for the last decade, you have accumulated a wealth of experience and knowledge that you can showcase during interviews. Recommended  to read and brush up for your interview: Must know interview questions and concept for any Java Interview Spring boot interview Questions for 10 years experiance This blog post will provide you with a list of commonly asked interview questions for 10 years experienced Java developers. It will also include detailed answers to each question, with explanations and examples to help you understand the concepts and their practical implementations better. Whether you are preparing for a job interview or just want to brush up your knowl
Read more

Sql Interview Questions for 10 Years Experience

Image
As an experienced SQL professional, you might encounter challenging questions during a job interview. In this blog post, we will explore 10 common SQL interview questions and provide in-depth explanations along with relevant examples. Let's dive in! Contents [ hide ] What is SQL Injection, and how can you prevent it? SQL Injection is a malicious attack where an attacker manipulates input data to execute unintended SQL statements. It can lead to unauthorized access, data breaches, and data manipulation. To prevent SQL Injection, follow these best practices: 1.1. Use Prepared Statements: Prepared statements or parameterized queries separate SQL code from data input, preventing attackers from injecting malicious SQL code. Here's an example in PHP: $stmt = $pdo->prepare('SELECT * FROM users WHERE username = :username'); $stmt->bindParam(':username', $username); $stmt->execute(); 1.2. Sanitize User Input: Validate and sanitize user input
Read more

Spring Boot Interview Questions for 10 Years Experience

Image
Welcome to the comprehensive guide on "Spring Boot Interview Questions for 10 Years Experience". Spring Boot has become one of the most popular frameworks for developing enterprise-grade applications, and its widespread adoption means that the demand for skilled Spring Boot developers has never been higher. If you are someone who has been working with Spring Boot for the last decade, you have accumulated a wealth of experience and knowledge that you can showcase during interviews. Recommended  to read and brush up for your interview: Must know interview questions and concept for any Java Interview Java Interview Questions for 10 Years Experience This blog post will provide you with a list of commonly asked interview questions for 10 years experienced Spring Boot developers. It will also include detailed answers to each question, with explanations and examples to help you understand the concepts and th
Read more

Visual Studio Code setup for Java and Spring with GitHub Copilot

Image
Introduction- In this tutorial blog, we will explore the process of setting up and utilising Visual Studio Code for Java programming, as well as incorporating GitHub Copilot as a valuable coding tool. Visual Studio Code is a powerful and versatile code editor that offers a wide range of features and extensions for Java developers. By using Visual Studio Code for Java programming, developers can benefit from features such as code completion, debugging, and live coding. Additionally, with the integration of GitHub Copilot, developers can streamline their coding process with AI-assisted suggestions for code snippets and functions. This blog will provide a comprehensive guide for setting up and using these tools for Java development. Contents [ hide ] Setup Visual Studio Code for Java and Spring Visual Studio Code (VS Code) is an open-source code editor that supports a wide range of programming languages, including Java. It is a powerful tool
Read more

Java interview questions - Must to know concepts

Contents [ hide ] How does Java achieve platform independence, and what is the underlying principle? Java programs can run on diverse operating systems and hardware setups without requiring modification. This feat is primarily achieved through the concept of the Java Virtual Machine (JVM). The Java Virtual Machine (JVM) The JVM acts as a bridge between the Java code you write and the underlying hardware and operating system . When you compile your Java code, it is translated into an intermediate form called bytecode, which is not tied to any specific platform. The JVM then comes into play. It takes this bytecode and dynamically translates it into machine-specific instructions that the host system can execute. This means that a Java program can be written once and executed on any system with the appropriate JVM for that system. Example: Running a Java Program on Different Platforms Consider a simple Java program that calculates the sum of two numbers: package codeKatha
Read more

Spring Data JPA

Image
Introduction- We will learn here Spring Data JPA, perform CRUD operation, Clear concept of Relationship mapping like one-to-many, many-to-one with Example. Spring Data JPA is a powerful framework that simplifies the process of working with relational databases in Java applications. It provides an easy-to-use API for working with JPA, allowing developers to focus on their business logic instead of worrying about the details of how JPA works. With Spring Data JPA, you can easily define entities that map to database tables, and then use them to perform CRUD (create, read, update, delete) operations on those tables. In addition, Spring Data JPA provides support for more advanced features like querying and pagination, making it an excellent choice for both small and large projects. Contents [ hide ] In this blog, we will explore Spring Data JPA by building a sample application that uses it to manage users and packs. But, before let
Read more

Data Structures & Algorithms Tutorial with Coding Interview Questions

Image
About the Course This course offers comprehensive coverage of coding questions that serve as a solid foundation for understanding DSA concepts. These questions are frequently asked in coding interviews, either directly or with some variations, by many companies, including Adobe, Facebook (Meta), Paytm, Amazon, Google, and others. Our primary objective is to enhance your problem-solving skills and enable you to devise optimal solutions. The course includes a wide range of topics, such as Arrays, Strings, Searching and Sorting, Greedy Algorithms, Trees, Graphs, Dynamic Programming, and more. Upon completion, you will possess the necessary skills to ace DSA interviews for typical companies or excel in the initial rounds of product-based companies such as Google, Microsoft and similar others. We are started with Graph data Structure and add others soon. Contents [ hide ] Approach Our course is  organised into chapters that foll
Read more

Elasticsearch Java Spring Boot

Image
Introduction- In this blog, we will learned how to use Elasticsearch with Spring Boot to build a search application. We will created several classes as an example, including ElasticsearchConfig, Book, BookService, BookController, and BookRepository, to demonstrate how to use Elasticsearch with Spring Boot. After this tutorial, you can start building your own search application using Elasticsearch and Spring Boot. Elasticsearch is a powerful search and analytics engine that can be used to build highly scalable and fault-tolerant applications. In this blog, we will learn how to use Elasticsearch with Spring Boot to build a search application. First we will Set up a Spring Boot project with Elasticsearch after that we will see how to make connection with elasticsearch. Once connection setupt is done then we will add data then perform queries and searching on Elasticsearch. Contents [ hide ] Setting up a Spring Boot project with Elas
Read more

Java interview questions for 5 years experience

Contents [ hide ] What is difference between Heap and Stack Memory in Java, and shed light on their utilization? In Java, memory management plays a crucial role in determining how objects are stored and accessed during program execution . Heap and Stack Memory are two distinct regions where different types of data are managed. Understanding their differences is essential for efficient memory utilisation and managing object lifecycles. Stack Memory Stack Memory is a region used for storing method calls, local variables, and references to objects . It operates in a Last-In-First-Out (LIFO) manner , resembling a stack of items. Each method call creates a new frame in the stack, containing variables specific to that method. Stack Memory is relatively fast for allocation and deallocation because it follows a strict order. However, it has limited space and is typically used for small, short-lived data. Primitive data types and references to objects are often stored here. Ex
Read more