Convert Adjacency List to Adjacency Matrix representation of a Graph

Given an adjacency list representation of a Graph, the task is to convert the given Adjacency List to Adjacency Matrix representation.

Examples:

Input: adjList[] = {{0 –> 1 –> 3}, {1 –> 2}, {2 –> 3}} 
Output:
0 1 0 1
0 0 1 0
0 0 0 1
0 0 0 0

Input: adjList[] = {{0 –> 1 –> 4}, {1 –> 0 –> 2 –> 3 –> 4}, {2 –> 1 –> 3}, {3 –> 1 –> 2 –> 4}, {4 –> 0 –> 1 –> 3}} 
Output:
0 1 0 0 1
1 0 1 1 1
0 1 0 1 0
0 1 1 0 1
1 1 0 1 0 

Adjacency List: An array of lists is used. The size of the array is equal to the number of vertices. Let the array be an array[]. An entry array[i] represents the list of vertices adjacent to the i^th Vertex.

Adjacency Matrix: Adjacency Matrix is a 2D array of size V x V where V is the number of vertices in a graph. Let the 2D array be adj[][], a slot adj[i][j] = 1 indicates that there is an edge from vertex i to vertex j.

Follow the steps below to convert an adjacency list to an adjacency matrix: 

• Initialize a matrix with 0s.
• Iterate over the vertices in the adjacency list
• For every j^th vertex in the adjacency list, traverse its edges.
• For each vertex i with which the j^th vertex has an edge, set mat[i][j] = 1.

Below is the implementation of the above approach:

C++

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to insert vertices to adjacency list
void insert(vector<int> adj[], int u, int v)
{
    // Insert a vertex v to vertex u
    adj[u].push_back(v);
    return;
}

// Function to display adjacency list
void printList(vector<int> adj[], int V)
{
    for (int i = 0; i < V; i++) {
        cout << i;
        for (auto j : adj[i])
            cout << " --> " << j;
        cout << endl;
    }
    cout << endl;
}

// Function to convert adjacency
// list to adjacency matrix
vector<vector<int> > convert(vector<int> adj[],
                             int V)
{
    // Initialize a matrix
    vector<vector<int> > matrix(V,
                                vector<int>(V, 0));

    for (int i = 0; i < V; i++) {
        for (auto j : adj[i])
            matrix[i][j] = 1;
    }
    return matrix;
}

// Function to display adjacency matrix
void printMatrix(vector<vector<int> > adj, int V)
{
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            cout << adj[i][j] << "   ";
        }
        cout << endl;
    }
    cout << endl;
}

// Driver code
int main()
{
    int V = 5;

    vector<int> adjList[V];

    // Inserting edges
    insert(adjList, 0, 1);
    insert(adjList, 0, 4);
    insert(adjList, 1, 0);
    insert(adjList, 1, 2);
    insert(adjList, 1, 3);
    insert(adjList, 1, 4);
    insert(adjList, 2, 1);
    insert(adjList, 2, 3);
    insert(adjList, 3, 1);
    insert(adjList, 3, 2);
    insert(adjList, 3, 4);
    insert(adjList, 4, 0);
    insert(adjList, 4, 1);
    insert(adjList, 4, 3);

    // Display adjacency list
    cout << "Adjacency List: \n";
    printList(adjList, V);

    // Function call which returns
    // adjacency matrix after conversion
    vector<vector<int> > adjMatrix
        = convert(adjList, V);

    // Display adjacency matrix
    cout << "Adjacency Matrix: \n";
    printMatrix(adjMatrix, V);

    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;

class GFG{

// Function to insert vertices to adjacency list
static void insert(Vector<Integer> adj[],
                   int u, int v)
{

    // Insert a vertex v to vertex u
    adj[u].add(v);
    return;
}

// Function to display adjacency list
static void printList(Vector<Integer> adj[],
                      int V)
{
    for(int i = 0; i < V; i++)
    {
        System.out.print(i);

        for(int j : adj[i])
            System.out.print(" --> " + j);

        System.out.println();
    }
    System.out.println();
}

// Function to convert adjacency
// list to adjacency matrix
static int[][] convert(Vector<Integer> adj[],
                       int V)
{

    // Initialize a matrix
    int [][]matrix = new int[V][V];

    for(int i = 0; i < V; i++)
    {
        for(int j : adj[i])
            matrix[i][j] = 1;
    }
    return matrix;
}

// Function to display adjacency matrix
static void printMatrix(int[][] adj, int V)
{
    for(int i = 0; i < V; i++)
    {
        for(int j = 0; j < V; j++)
        {
            System.out.print(adj[i][j] + " ");
        }
        System.out.println();
    }
    System.out.println();
}

// Driver code
public static void main(String[] args)
{
    int V = 5;

    @SuppressWarnings("unchecked")
    Vector<Integer> []adjList = new Vector[V];
    for(int i = 0; i < adjList.length; i++)
        adjList[i] = new Vector<Integer>();

    // Inserting edges
    insert(adjList, 0, 1);
    insert(adjList, 0, 4);
    insert(adjList, 1, 0);
    insert(adjList, 1, 2);
    insert(adjList, 1, 3);
    insert(adjList, 1, 4);
    insert(adjList, 2, 1);
    insert(adjList, 2, 3);
    insert(adjList, 3, 1);
    insert(adjList, 3, 2);
    insert(adjList, 3, 4);
    insert(adjList, 4, 0);
    insert(adjList, 4, 1);
    insert(adjList, 4, 3);

    // Display adjacency list
    System.out.print("Adjacency List: \n");
    printList(adjList, V);

    // Function call which returns
    // adjacency matrix after conversion
    int[][] adjMatrix = convert(adjList, V);

    // Display adjacency matrix
    System.out.print("Adjacency Matrix: \n");
    printMatrix(adjMatrix, V);
}
}

// This code is contributed by amal kumar choubey

Python3

# Python3 program to implement
# the above approach

# Function to insert vertices
# to adjacency list
def insert(adj, u, v):

    # Insert a vertex v to vertex u
    adj[u].append(v)
    return

# Function to display adjacency list
def printList(adj, V):

    for i in range(V):
        print(i, end = '')

        for j in adj[i]:
            print(' --> ' + str(j), end = '')

        print()

    print()

# Function to convert adjacency
# list to adjacency matrix
def convert(adj, V):

    # Initialize a matrix
    matrix = [[0 for j in range(V)]
                 for i in range(V)]

    for i in range(V):
        for j in adj[i]:
            matrix[i][j] = 1

    return matrix

# Function to display adjacency matrix
def printMatrix(adj, V):

    for i in range(V):
        for j in range(V):
            print(adj[i][j], end = ' ')

        print()

    print()

# Driver code
if __name__=='__main__':

    V = 5

    adjList = [[] for i in range(V)]

    # Inserting edges
    insert(adjList, 0, 1)
    insert(adjList, 0, 4)
    insert(adjList, 1, 0)
    insert(adjList, 1, 2)
    insert(adjList, 1, 3)
    insert(adjList, 1, 4)
    insert(adjList, 2, 1)
    insert(adjList, 2, 3)
    insert(adjList, 3, 1)
    insert(adjList, 3, 2)
    insert(adjList, 3, 4)
    insert(adjList, 4, 0)
    insert(adjList, 4, 1)
    insert(adjList, 4, 3)

    # Display adjacency list
    print("Adjacency List: ")
    printList(adjList, V)

    # Function call which returns
    # adjacency matrix after conversion
    adjMatrix = convert(adjList, V)

    # Display adjacency matrix
    print("Adjacency Matrix: ")
    printMatrix(adjMatrix, V)

# This code is contributed by rutvik_56

C#

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;

class GFG{

// Function to insert vertices to adjacency list
static void insert(List<int> []adj,
                        int u, int v)
{

    // Insert a vertex v to vertex u
    adj[u].Add(v);
    return;
}

// Function to display adjacency list
static void printList(List<int> []adj,
                           int V)
{
    for(int i = 0; i < V; i++)
    {
        Console.Write(i);

        foreach(int j in adj[i])
            Console.Write(" --> " + j);

        Console.WriteLine();
    }
    Console.WriteLine();
}

// Function to convert adjacency
// list to adjacency matrix
static int[,] convert(List<int> []adj,
                           int V)
{

    // Initialize a matrix
    int [,]matrix = new int[V, V];

    for(int i = 0; i < V; i++)
    {
        foreach(int j in adj[i])
            matrix[i, j] = 1;
    }
    return matrix;
}

// Function to display adjacency matrix
static void printMatrix(int[,] adj, int V)
{
    for(int i = 0; i < V; i++)
    {
        for(int j = 0; j < V; j++)
        {
            Console.Write(adj[i, j] + " ");
        }
        Console.WriteLine();
    }
    Console.WriteLine();
}

// Driver code
public static void Main(String[] args)
{
    int V = 5;

    List<int> []adjList = new List<int>[V];
    for(int i = 0; i < adjList.Length; i++)
        adjList[i] = new List<int>();

    // Inserting edges
    insert(adjList, 0, 1);
    insert(adjList, 0, 4);
    insert(adjList, 1, 0);
    insert(adjList, 1, 2);
    insert(adjList, 1, 3);
    insert(adjList, 1, 4);
    insert(adjList, 2, 1);
    insert(adjList, 2, 3);
    insert(adjList, 3, 1);
    insert(adjList, 3, 2);
    insert(adjList, 3, 4);
    insert(adjList, 4, 0);
    insert(adjList, 4, 1);
    insert(adjList, 4, 3);

    // Display adjacency list
    Console.Write("Adjacency List: \n");
    printList(adjList, V);

    // Function call which returns
    // adjacency matrix after conversion
    int[,] adjMatrix = convert(adjList, V);

    // Display adjacency matrix
    Console.Write("Adjacency Matrix: \n");
    printMatrix(adjMatrix, V);
}
}

// This code is contributed by amal kumar choubey

Javascript

<script>

// Javascript program to implement
// the above approach

// Function to insert vertices to adjacency list
function insert(adj, u, v)
{

    // Insert a vertex v to vertex u
    adj[u].push(v);
    return;
}

// Function to display adjacency list
function printList(adj, V)
{
    for(var i = 0; i < V; i++)
    {
        document.write(i);

        for(var j of adj[i])
            document.write(" --> " + j);

        document.write("<br>");
    }
    document.write("<br>");
}

// Function to convert adjacency
// list to adjacency matrix
function convert(adj, V)
{

    // Initialize a matrix
    var matrix = Array.from(Array(V), ()=>Array(V).fill(0));
    for (var i = 0; i < V; i++) {
        for (var j of adj[i])
            matrix[i][j] = 1;
    }
    return matrix;
}

// Function to display adjacency matrix
function printMatrix(adj, V)
{
    for(var i = 0; i < V; i++)
    {
        for(var j = 0; j < V; j++)
        {
            document.write(adj[i][j] + " ");
        }
        document.write("<br>");
    }
    document.write("<br>");
}

// Driver code
var V = 5;
var adjList = Array.from(Array(V), ()=>Array().fill(0));

// Inserting edges
insert(adjList, 0, 1);
insert(adjList, 0, 4);
insert(adjList, 1, 0);
insert(adjList, 1, 2);
insert(adjList, 1, 3);
insert(adjList, 1, 4);
insert(adjList, 2, 1);
insert(adjList, 2, 3);
insert(adjList, 3, 1);
insert(adjList, 3, 2);
insert(adjList, 3, 4);
insert(adjList, 4, 0);
insert(adjList, 4, 1);
insert(adjList, 4, 3);
// Display adjacency list
document.write("Adjacency List: <br>");
printList(adjList, V);
// Function call which returns
// adjacency matrix after conversion
var adjMatrix = convert(adjList, V);
// Display adjacency matrix
document.write("Adjacency Matrix: <br>");
printMatrix(adjMatrix, V);


</script>

Output:

Adjacency List: 
0 --> 1 --> 4
1 --> 0 --> 2 --> 3 --> 4
2 --> 1 --> 3
3 --> 1 --> 2 --> 4
4 --> 0 --> 1 --> 3

Adjacency Matrix: 
0   1   0   0   1   
1   0   1   1   1   
0   1   0   1   0   
0   1   1   0   1   
1   1   0   1   0

Time Complexity: O(N*M) 
Auxiliary Space: O(N²)