C program to implement Adjacency Matrix of a given Graph

Given a undirected Graph of N vertices 1 to N and M edges in form of 2D array arr[][] whose every row consists of two numbers X and Y which denotes that there is a edge between X and Y, the task is to write C program to create Adjacency Matrix of the given Graph.

Examples:

Input: N = 5, M = 4, arr[][] = { { 1, 2 }, { 2, 3 }, { 4, 5 }, { 1, 5 } }
Output:
0 1 0 0 1
1 0 1 0 0
0 1 0 0 0
0 0 0 0 1
1 0 0 1 0

Input: N = 3, M = 4, arr[][] = { { 1, 2 }, { 2, 3 }, { 3, 1 }, { 2, 2 } }
Output:
0 1 1
1 1 1
1 1 0

Approach: The idea is to use a square Matrix of size NxN to create Adjacency Matrix. Below are the steps:

Create a 2D array(say Adj[N+1][N+1]) of size NxN and initialise all value of this matrix to zero.
For each edge in arr[][](say X and Y), Update value at Adj[X][Y] and Adj[Y][X] to 1, denotes that there is a edge between X and Y.
Display the Adjacency Matrix after the above operation for all the pairs in arr[][].

Below is the implementation of the above approach:

// C program for the above approach 
#include <stdio.h> 
  
// N vertices and M Edges 
int N, M; 
  
// Function to create Adjacency Matrix 
void createAdjMatrix(int Adj[][N + 1], 
                     int arr[][2]) 
{ 
  
    // Initialise all value to this 
    // Adjacency list to zero 
    for (int i = 0; i < N + 1; i++) { 
  
        for (int j = 0; j < N + 1; j++) { 
            Adj[i][j] = 0; 
        } 
    } 
  
    // Traverse the array of Edges 
    for (int i = 0; i < M; i++) { 
  
        // Find X and Y of Edges 
        int x = arr[i][0]; 
        int y = arr[i][1]; 
  
        // Update value to 1 
        Adj[x][y] = 1; 
        Adj[y][x] = 1; 
    } 
} 
  
// Function to print the created 
// Adjacency Matrix 
void printAdjMatrix(int Adj[][N + 1]) 
{ 
  
    // Traverse the Adj[][] 
    for (int i = 1; i < N + 1; i++) { 
        for (int j = 1; j < N + 1; j++) { 
  
            // Print the value at Adj[i][j] 
            printf("%d ", Adj[i][j]); 
        } 
        printf("\n"); 
    } 
} 
  
// Driver Code 
int main() 
{ 
  
    // Number of vertices 
    N = 5; 
  
    // Given Edges 
    int arr[][2] 
        = { { 1, 2 }, { 2, 3 },  
            { 4, 5 }, { 1, 5 } }; 
  
    // Number of Edges 
    M = sizeof(arr) / sizeof(arr[0]); 
  
    // For Adjacency Matrix 
    int Adj[N + 1][N + 1]; 
  
    // Function call to create 
    // Adjacency Matrix 
    createAdjMatrix(Adj, arr); 
  
    // Print Adjacency Matrix 
    printAdjMatrix(Adj); 
  
    return 0; 
} 

Output:

Time Complexity: O(N²), where N is the number of vertices in a graph.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes

Recommended Posts: