Adjacency List from Edges

Given an undirected graph with V vertices (0-based indexing) and edges, create an adjacency list of the graph.

Examples:

Input: V = 5, edges = [[0,1], [0,4], [4,1], [4,3], [1,3], [1,2], [3,2]]
 

Output: [[1,4], [0,2,3,4], [1,3], [1,2,4], [0,1,3]]

Explanation:

• Node 0 is connected to 1 and 4.
• Node 1 is connected to 0,2,3 and 4.
• Node 2 is connected to 1 and 3.
• Node 3 is connected to 1,2 and 4.
• Node 4 is connected to 0,1 and 3.

Input: V = 4, edges = [[0,3], [0,2], [2,1]]

Output: [[2,3], [2], [0,1], [0]]

Explanation:

• Node 0 is connected to 2 and 3.
• Node 1 is only connected to 2.
• Node 2 is connected to 0 and 1.
• Node 3 is only connected to 0.

Consider the graph V = 4, edges = [[0,3], [0,2], [2,1]]. Here are the steps to build its adjacency list.

Step 1: Initialize empty lists for each vertex: 0: [], 1: [], 2: [], 3: [], 4: []

Step 2: For each edge [u, v], since this is undirected, we add v to u's list and u to v's list.

• Edge [0,3] - Add 3 to 0’s list and 0 to 3’s list: 0: [3], 1: [], 2: [], 3: [0]
• Edge [0,2] - Add 2 to 0’s list and 0 to 2’s list: 0: [3, 2], 1: [], 2: [0], 3: [0]
• Edge [2,1] - Add 1 to 2’s list and 2 to 1’s list: 0: [3, 2], 1: [2], 2: [0, 1], 3: [0]

Step 3: Final adjacency list: 0: [3, 2], 1: [2], 2: [0, 1], 3: [0]. Each list represents the neighbors of that vertex.

using namespace std;

// Function to return adjacency list of undirected graph
vector<vector<int>> printGraph(int V, vector<pair<int, int>> &edges)
{

    // Initialize adjacency list with V empty lists
    vector<vector<int>> adj(V);

    // Traverse all edges
    for (auto edge : edges)
    {
        int u = edge.first;
        int v = edge.second;

        // Add edge to adjacency list (undirected)
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    return adj;
}

int main()
{
    int V = 4;
    vector<pair<int, int>> edges = { { 0, 3 }, { 0, 2 }, { 2, 1 } };

    vector<vector<int>> adj = printGraph(V, edges);

    // Print adjacency list
    for (int i = 0; i < V; i++)
    {
        cout << i << ": ";
        for (int x : adj[i])
            cout << x << " ";
        cout << endl;
    }

    return 0;
}

import java.util.ArrayList;
import java.util.List;

class GFG {

    // Function to return adjacency list of undirected graph
    public List<List<Integer> > printGraph(int V,
                                           int[][] edges)
    {

        // Initialize adjacency list
        List<List<Integer> > adj = new ArrayList<>();
        for (int i = 0; i < V; i++)
            adj.add(new ArrayList<>());

        // Traverse all edges
        for (int i = 0; i < edges.length; i++) {
            int u = edges[i][0];
            int v = edges[i][1];

            // Add edge to adjacency list (undirected)
            adj.get(u).add(v);
            adj.get(v).add(u);
        }

        return adj;
    }
    public static void main(String[] args)
    {
        GFG obj = new GFG();
        int V = 4;
        int[][] edges = { { 0, 3 }, { 0, 2 }, { 2, 1 } };

        List<List<Integer> > adj = obj.printGraph(V, edges);

        // Print adjacency list
        for (int i = 0; i < V; i++) {
            System.out.print(i + ": ");
            for (int x : adj.get(i))
                System.out.print(x + " ");
            System.out.println();
        }
    }
}

from typing import List

# Function to create adjacency list of undirected graph
def printGraph(V: int, edges: List[List[int]]) -> List[List[int]]:

    # Initialize adjacency list
    adj = [[] for _ in range(V)]

    # Traverse all edges
    for node1, node2 in edges:

        # Add edge to adjacency list (undirected)
        adj[node1].append(node2)
        adj[node2].append(node1)

    return adj


if __name__ == "__main__":
    V = 4
    edges = [[0,3], [0,2], [2,1]]
    adj = printGraph(V, edges)

 # Print adjacency list
    for i in range(V):
        print(i, ":", *adj[i])

using System;
using System.Collections.Generic;

class GFG {

    // Function to return adjacency list of undirected graph
    public List<List<int> > printGraph(int V, int[, ] edges)
    {

        // Initialize adjacency list
        List<List<int> > adj = new List<List<int> >();
        for (int i = 0; i < V; i++)
            adj.Add(new List<int>());

        // Traverse all edges
        for (int i = 0; i < edges.GetLength(0); i++) {
            int u = edges[i, 0];
            int v = edges[i, 1];

            // Add edge to adjacency list (undirected)
            adj[u].Add(v);
            adj[v].Add(u);
        }

        return adj;
    }

    public static void Main(string[] args)
    {
        GFG obj = new GFG();
        int V = 4;
        int[, ] edges= { { 0, 3 }, { 0, 2 }, { 2, 1 } };

        List<List<int> > adj = obj.printGraph(V, edges);

        // Print adjacency list
        for (int i = 0; i < V; i++) {
            Console.Write(i + ": ");
            foreach(int x in adj[i]) Console.Write(x + " ");
            Console.WriteLine();
        }
    }
}

// Function to create adjacency list of undirected graph
function printGraph(V, edges) {
    
     // Initialize adjacency list
    const graph = new Array(V).fill().map(() => []);

    // Traverse all edges
    for (const edge of edges) {
        const [src, dest] = edge;
        graph[src].push(dest);
        graph[dest].push(src);
    }

    return graph;
}

// Driver code
const V = 4;
const edges = [[0,3], [0,2], [2,1]];
const adj = printGraph(V, edges);

// Print adjacency list
for (let i = 0; i < V; i++) {
    console.log(i, ":", ...adj[i]);
}

0: 3 2 
1: 2 
2: 0 1 
3: 0 

Time Complexity:  O(V+E), where V = number of vertices, E = number of edges.
Auxiliary Space: O(V + E) (average case), O(V²) (worst case if fully connected)