Skip to content

Types of Graphs with Examples

Graph and its representations

Last Updated : 21 Jun, 2025

A Graph is a non-linear data structure consisting of vertices and edges. The vertices are sometimes also referred to as nodes and the edges are lines or arcs that connect any two nodes in the graph. More formally a Graph is composed of a set of vertices( V ) and a set of edges( E ). The graph is denoted by G(V, E).

Representations of Graph

Here are the two most common ways to represent a graph : For simplicity, we are going to consider only unweighted graphs in this post.

Adjacency Matrix
Adjacency List

Adjacency Matrix Representation

An adjacency matrix is a way of representing a graph as a matrix of boolean (0's and 1's)

Let's assume there are n vertices in the graph So, create a 2D matrix adjMat[n][n] having dimension n x n.

If there is an edge from vertex i to j, mark adjMat[i][j] as 1.
If there is no edge from vertex i to j, mark adjMat[i][j] as 0.

Representation of Undirected Graph as Adjacency Matrix:

The below figure shows an undirected graph. Initially, the entire Matrix is initialized to 0. If there is an edge from source to destination, we insert 1 to both cases (adjMat[source][destination] and adjMat[destination][source]) because we can go either way.

Undirected_to_Adjacency_matrix — Undirected Graph to Adjacency Matrix

C++

// C++ program to demonstrate Adjacency Matrix // representation of undirected and unweighted graph #include <bits/stdc++.h> using namespace std;  void addEdge(vector<vector<int>> &mat, int i, int j) {     mat[i][j] = 1;     mat[j][i] = 1; // Since the graph is undirected }  void displayMatrix(vector<vector<int>> &mat) {     int V = mat.size();     for (int i = 0; i < V; i++)     {         for (int j = 0; j < V; j++)             cout << mat[i][j] << " ";         cout << endl;     } }  int main() {      // Create a graph with 4 vertices and no edges     // Note that all values are initialized as 0     int V = 4;     vector<vector<int>> mat(V, vector<int>(V, 0));      // Now add edges one by one     addEdge(mat, 0, 1);     addEdge(mat, 0, 2);     addEdge(mat, 1, 2);     addEdge(mat, 2, 3);      /* Alternatively we can also create using below        code if we know all edges in advacem       vector<vector<int>> mat = {{ 0, 1, 0, 0 },                                { 1, 0, 1, 0 },                                { 0, 1, 0, 1 },                                { 0, 0, 1, 0 } }; */      cout << "Adjacency Matrix Representation" << endl;     displayMatrix(mat);      return 0; }

C

#include<stdio.h>  #define V 4  void addEdge(int mat[V][V], int i, int j) {     mat[i][j] = 1;     mat[j][i] = 1; // Since the graph is undirected }  void displayMatrix(int mat[V][V]) {     for (int i = 0; i < V; i++) {         for (int j = 0; j < V; j++)             printf("%d ", mat[i][j]);         printf("\n");     } }  int main() {     // Create a graph with 4 vertices and no edges     // Note that all values are initialized as 0     int mat[V][V] = {0};      // Now add edges one by one     addEdge(mat, 0, 1);     addEdge(mat, 0, 2);     addEdge(mat, 1, 2);     addEdge(mat, 2, 3);      /* Alternatively, we can also create using the below        code if we know all edges in advance      int mat[V][V] = {         {0, 1, 0, 0},         {1, 0, 1, 0},         {0, 1, 0, 1},         {0, 0, 1, 0}     }; */      printf("Adjacency Matrix Representation\n");     displayMatrix(mat);      return 0; }

Java

import java.util.Arrays;  public class GfG {      public static void addEdge(int[][] mat, int i, int j) {         mat[i][j] = 1;         mat[j][i] = 1; // Since the graph is undirected     }      public static void displayMatrix(int[][] mat) {         for (int[] row : mat) {             for (int val : row) {                 System.out.print(val + " ");             }             System.out.println();         }     }      public static void main(String[] args) {          // Create a graph with 4 vertices and no edges         // Note that all values are initialized as 0         int V = 4;         int[][] mat = new int[V][V];          // Now add edges one by one         addEdge(mat, 0, 1);         addEdge(mat, 0, 2);         addEdge(mat, 1, 2);         addEdge(mat, 2, 3);          /* Alternatively we can also create using below            code if we know all edges in advance           int[][] mat = {{ 0, 1, 0, 0 },                         { 1, 0, 1, 0 },                         { 0, 1, 0, 1 },                         { 0, 0, 1, 0 } }; */          System.out.println("Adjacency Matrix Representation");         displayMatrix(mat);     } }

Python

def add_edge(mat, i, j):        # Add an edge between two vertices     mat[i][j] = 1  # Graph is      mat[j][i] = 1  # Undirected  def display_matrix(mat):        # Display the adjacency matrix     for row in mat:         print(" ".join(map(str, row)))    # Main function to run the program if __name__ == "__main__":     V = 4  # Number of vertices     mat = [[0] * V for _ in range(V)]        # Add edges to the graph     add_edge(mat, 0, 1)     add_edge(mat, 0, 2)     add_edge(mat, 1, 2)     add_edge(mat, 2, 3)      # Optionally, initialize matrix directly     """     mat = [         [0, 1, 0, 0],         [1, 0, 1, 0],         [0, 1, 0, 1],         [0, 0, 1, 0]     ]     """      # Display adjacency matrix     print("Adjacency Matrix:")     display_matrix(mat)

C#

using System;  public class GfG {     // Add an edge between two vertices     public static void AddEdge(int[,] mat, int i, int j)     {         mat[i, j] = 1; // Since the graph is          mat[j, i] = 1; // undirected     }      // Display the adjacency matrix     public static void DisplayMatrix(int[,] mat)     {         int V = mat.GetLength(0);          for (int i = 0; i < V; i++)         {             for (int j = 0; j < V; j++)             {                 Console.Write(mat[i, j] + " ");             }             Console.WriteLine();          }     }      // Main method to run the program     public static void Main(string[] args)     {         int V = 4; // Number of vertices         int[,] mat = new int[V, V]; // Initialize matrix          // Add edges to the graph         AddEdge(mat, 0, 1);         AddEdge(mat, 0, 2);         AddEdge(mat, 1, 2);         AddEdge(mat, 2, 3);          // Optionally, initialize matrix directly         /*         int[,] mat = new int[,]         {             { 0, 1, 0, 0 },             { 1, 0, 1, 0 },             { 0, 1, 0, 1 },             { 0, 0, 1, 0 }         };         */          // Display adjacency matrix         Console.WriteLine("Adjacency Matrix:");         DisplayMatrix(mat);     } }

JavaScript

function addEdge(mat, i, j) {     mat[i][j] = 1; // Graph is      mat[j][i] = 1; // undirected }  function displayMatrix(mat) {     // Display the adjacency matrix     for (const row of mat) {         console.log(row.join(" "));      } }  // Main function to run the program const V = 4; // Number of vertices   // Initialize matrix let mat = Array.from({ length: V }, () => Array(V).fill(0));  // Add edges to the graph addEdge(mat, 0, 1); addEdge(mat, 0, 2); addEdge(mat, 1, 2); addEdge(mat, 2, 3);  /* Optionally, initialize matrix directly let mat = [     [0, 1, 0, 0],     [1, 0, 1, 0],     [0, 1, 0, 1],     [0, 0, 1, 0] ]; */  // Display adjacency matrix console.log("Adjacency Matrix:"); displayMatrix(mat);

Output

Adjacency Matrix Representation 0 1 1 0  1 0 1 0  1 1 0 1  0 0 1 0

Representation of Directed Graph as Adjacency Matrix:

The below figure shows a directed graph. Initially, the entire Matrix is initialized to 0. If there is an edge from source to destination, we insert 1 for that particular adjMat[source][destination].

Directed_to_Adjacency_matrix — Directed Graph to Adjacency Matrix

Please refer Adjacency Matrix Representation for more details.

Adjacency List Representation

An array of Lists is used to store edges between two vertices. The size of array is equal to the number of vertices (i.e, n). Each index in this array represents a specific vertex in the graph. The entry at the index i of the array contains a linked list containing the vertices that are adjacent to vertex i. Let's assume there are n vertices in the graph So, create an array of list of size n as adjList[n].

adjList[0] will have all the nodes which are connected (neighbour) to vertex 0.
adjList[1] will have all the nodes which are connected (neighbour) to vertex 1 and so on.

Representation of Undirected Graph as Adjacency list:

The below undirected graph has 3 vertices. So, an array of list will be created of size 3, where each indices represent the vertices. Now, vertex 0 has two neighbours (i.e, 1 and 2). So, insert vertex 1 and 2 at indices 0 of array. Similarly, For vertex 1, it has two neighbour (i.e, 2 and 0) So, insert vertices 2 and 0 at indices 1 of array. Similarly, for vertex 2, insert its neighbours in array of list.

Graph-Representation-of-Undirected-graph-to-Adjacency-List — Undirected Graph to Adjacency list

C++

#include <iostream> #include <vector> using namespace std;  // Function to add an edge between two vertices void addEdge(vector<vector<int>>& adj, int i, int j) {     adj[i].push_back(j);     adj[j].push_back(i); // Undirected }  // Function to display the adjacency list void displayAdjList(const vector<vector<int>>& adj) {     for (int i = 0; i < adj.size(); i++) {         cout << i << ": "; // Print the vertex         for (int j : adj[i]) {             cout << j << " "; // Print its adjacent         }         cout << endl;      } }  // Main function int main() {     // Create a graph with 4 vertices and no edges     int V = 4;     vector<vector<int>> adj(V);       // Now add edges one by one     addEdge(adj, 0, 1);     addEdge(adj, 0, 2);     addEdge(adj, 1, 2);     addEdge(adj, 2, 3);      cout << "Adjacency List Representation:" << endl;     displayAdjList(adj);      return 0; }

C

#include <stdio.h> #include <stdlib.h>  // Structure for a node in the adjacency list struct Node {     int data;     struct Node* next; };  // Function to create a new node struct Node* createNode(int data) {     struct Node* newNode =        (struct Node*)malloc(sizeof(struct Node));     newNode->data = data;     newNode->next = NULL;     return newNode; }  // Function to add an edge between two vertices void addEdge(struct Node* adj[], int i, int j) {     struct Node* newNode = createNode(j);     newNode->next = adj[i];     adj[i] = newNode;      newNode = createNode(i); // For undirected graph     newNode->next = adj[j];     adj[j] = newNode; }  // Function to display the adjacency list void displayAdjList(struct Node* adj[], int V) {     for (int i = 0; i < V; i++) {         printf("%d: ", i); // Print the vertex         struct Node* temp = adj[i];         while (temp != NULL) {             printf("%d ", temp->data); // Print its adjacent             temp = temp->next;         }         printf("\n");     } }  // Main function int main() {        // Create a graph with 4 vertices and no edges     int V = 4;     struct Node* adj[V];     for (int i = 0; i < V; i++) {         adj[i] = NULL; // Initialize adjacency list     }      // Now add edges one by one     addEdge(adj, 0, 1);     addEdge(adj, 0, 2);     addEdge(adj, 1, 2);     addEdge(adj, 2, 3);      printf("Adjacency List Representation:\n");     displayAdjList(adj, V);      return 0; }

Java

import java.util.ArrayList; import java.util.List;  public class GfG {          // Method to add an edge between two vertices     public static void addEdge(List<List<Integer>> adj, int i, int j) {         adj.get(i).add(j);         adj.get(j).add(i); // Undirected     }      // Method to display the adjacency list     public static void displayAdjList(List<List<Integer>> adj) {         for (int i = 0; i < adj.size(); i++) {             System.out.print(i + ": "); // Print the vertex             for (int j : adj.get(i)) {                 System.out.print(j + " "); // Print its adjacent              }             System.out.println();          }     }      // Main method     public static void main(String[] args) {                // Create a graph with 4 vertices and no edges         int V = 4;         List<List<Integer>> adj = new ArrayList<>(V);          for (int i = 0; i < V; i++) {             adj.add(new ArrayList<>());         }          // Now add edges one by one         addEdge(adj, 0, 1);         addEdge(adj, 0, 2);         addEdge(adj, 1, 2);         addEdge(adj, 2, 3);          System.out.println("Adjacency List Representation:");         displayAdjList(adj);     } }

Python

def add_edge(adj, i, j):     adj[i].append(j)     adj[j].append(i)  # Undirected  def display_adj_list(adj):     for i in range(len(adj)):         print(f"{i}: ", end="")         for j in adj[i]:             print(j, end=" ")         print()  # Create a graph with 4 vertices and no edges V = 4 adj = [[] for _ in range(V)]  # Now add edges one by one add_edge(adj, 0, 1) add_edge(adj, 0, 2) add_edge(adj, 1, 2) add_edge(adj, 2, 3)  print("Adjacency List Representation:") display_adj_list(adj)

C#

using System; using System.Collections.Generic;  public class GfG {     // Method to add an edge between two vertices     public static void AddEdge(List<List<int>> adj, int i, int j)     {         adj[i].Add(j);         adj[j].Add(i); // Undirected     }      // Method to display the adjacency list     public static void DisplayAdjList(List<List<int>> adj)     {         for (int i = 0; i < adj.Count; i++)         {             Console.Write($"{i}: "); // Print the vertex             foreach (int j in adj[i])             {                 Console.Write($"{j} "); // Print its adjacent             }             Console.WriteLine();          }     }      // Main method     public static void Main(string[] args)     {         // Create a graph with 4 vertices and no edges         int V = 4;         List<List<int>> adj = new List<List<int>>(V);          for (int i = 0; i < V; i++)             adj.Add(new List<int>());          // Now add edges one by one         AddEdge(adj, 0, 1);         AddEdge(adj, 0, 2);         AddEdge(adj, 1, 2);         AddEdge(adj, 2, 3);          Console.WriteLine("Adjacency List Representation:");         DisplayAdjList(adj);     } }

JavaScript

function addEdge(adj, i, j) {     adj[i].push(j);     adj[j].push(i); // Undirected }  function displayAdjList(adj) {     for (let i = 0; i < adj.length; i++) {         console.log(`${i}: `);          for (const j of adj[i]) {              console.log(`${j} `);          }         console.log();      } }  // Create a graph with 4 vertices and no edges const V = 4; const adj = Array.from({ length: V }, () => []);  // Now add edges one by one addEdge(adj, 0, 1); addEdge(adj, 0, 2); addEdge(adj, 1, 2); addEdge(adj, 2, 3);  console.log("Adjacency List Representation:"); displayAdjList(adj);

Output

Adjacency List Representation: 0: 1 2  1: 0 2  2: 0 1 3  3: 2

Representation of Directed Graph as Adjacency list:

The below directed graph has 3 vertices. So, an array of list will be created of size 3, where each indices represent the vertices. Now, vertex 0 has no neighbours. For vertex 1, it has two neighbour (i.e, 0 and 2) So, insert vertices 0 and 2 at indices 1 of array. Similarly, for vertex 2, insert its neighbours in array of list.

Graph-Representation-of-Directed-graph-to-Adjacency-List

Please refer Adjacency List Representation for more details.

Types of Graphs with Examples

K

kartik

Improve

Article Tags :

Practice Tags :

Graph

Similar Reads

Graph Algorithms

Graph is a non-linear data structure like tree data structure. The limitation of tree is, it can only represent hierarchical data. For situations where nodes or vertices are randomly connected with each other other, we use Graph. Example situations where we use graph data structure are, a social net

Introduction to Graph Data Structure

Graph Data Structure is a non-linear data structure consisting of vertices and edges. It is useful in fields such as social network analysis, recommendation systems, and computer networks. In the field of sports data science, graph data structure can be used to analyze and understand the dynamics of

Graph and its representations

A Graph is a non-linear data structure consisting of vertices and edges. The vertices are sometimes also referred to as nodes and the edges are lines or arcs that connect any two nodes in the graph. More formally a Graph is composed of a set of vertices( V ) and a set of edges( E ). The graph is den

Types of Graphs with Examples

A graph is a mathematical structure that represents relationships between objects by connecting a set of points. It is used to establish a pairwise relationship between elements in a given set. graphs are widely used in discrete mathematics, computer science, and network theory to represent relation

Basic Properties of a Graph

A Graph is a non-linear data structure consisting of nodes and edges. The nodes are sometimes also referred to as vertices and the edges are lines or arcs that connect any two nodes in the graph. The basic properties of a graph include: Vertices (nodes): The points where edges meet in a graph are kn

Applications, Advantages and Disadvantages of Graph

Graph is a non-linear data structure that contains nodes (vertices) and edges. A graph is a collection of set of vertices and edges (formed by connecting two vertices). A graph is defined as G = {V, E} where V is the set of vertices and E is the set of edges. Graphs can be used to model a wide varie

Transpose graph

Transpose of a directed graph G is another directed graph on the same set of vertices with all of the edges reversed compared to the orientation of the corresponding edges in G. That is, if G contains an edge (u, v) then the converse/transpose/reverse of G contains an edge (v, u) and vice versa. Giv

Difference Between Graph and Tree

Graphs and trees are two fundamental data structures used in computer science to represent relationships between objects. While they share some similarities, they also have distinct differences that make them suitable for different applications. Difference Between Graph and Tree What is Graph?A grap