Open In App

C program to implement Adjacency Matrix of a given Graph

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

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:

  1. Create a 2D array(say Adj[N+1][N+1]) of size NxN and initialise all value of this matrix to zero.
  2. 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.
  3. Display the Adjacency Matrix after the above operation for all the pairs in arr[][].

Below is the implementation of the above approach: 

C




// 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:

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

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

Space Complexity: O(N^2), where N is the number of vertices.



Last Updated : 20 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads