Open In App

Adjacency List Representation

Last Updated : 07 Nov, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report

An adjacency list is a data structure used to represent a graph where each node in the graph stores a list of its neighboring vertices.

Table of Content

1. Adjacency List for Directed graph:

Consider an Directed and Unweighted graph G with 3 vertices and 3 edges. For the graph G, the adjacency list would look like:


C++ 
#include <iostream>
#include <vector>
using namespace std;

// Function to add an edge between two vertices
void addEdge(vector<vector<int>>& adj, int u, int v) {
    adj[u].push_back(v);
}

void displayAdjList(const vector<vector<int>>& adj) {
    for (int i = 0; i < adj.size(); i++) {
        cout << i << ": "; 
        for (int j : adj[i]) {
            cout << j << " "; 
        }
        cout << endl; 
    }
}

int main() {
  
    // Create a graph with 3 vertices and 3 edges
    int V = 3;
    vector<vector<int>> adj(V); 

    // Now add edges one by one
    addEdge(adj, 1, 0);
    addEdge(adj, 1, 2);
    addEdge(adj, 2, 0);

    cout << "Adjacency List Representation:" << endl;
    displayAdjList(adj);

    return 0;
}
Java 
import java.util.ArrayList;
import java.util.List;

class GfG {

    // Function to add an edge between two vertices
    static void addEdge(List<List<Integer>> adj, int u, int v) {
        adj.get(u).add(v);
    }

    static void displayAdjList(List<List<Integer>> adj) {
        for (int i = 0; i < adj.size(); i++) {
            System.out.print(i + ": ");
            for (int j : adj.get(i)) {
                System.out.print(j + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
      
        // Create a graph with 3 vertices and 3 edges
        int V = 3;
        List<List<Integer>> adj = new ArrayList<>();

        for (int i = 0; i < V; i++) {
            adj.add(new ArrayList<>());
        }

        // Now add edges one by one
        addEdge(adj, 1, 0);
        addEdge(adj, 1, 2);
        addEdge(adj, 2, 0);

        System.out.println("Adjacency List Representation:");
        displayAdjList(adj);
    }
}
Python 
# Function to add an edge between two vertices
def addEdge(adj, u, v):
    adj[u].append(v)


def displayAdjList(adj):
    for i in range(len(adj)):
        print(f"{i}: ", end="")
        for j in adj[i]:
            print(f"{j} ", end="")
        print()


def main():
  
    # Create a graph with 3 vertices and 3 edges
    V = 3
    adj = [[] for _ in range(V)]

    # Now add edges one by one
    addEdge(adj, 1, 0)
    addEdge(adj, 1, 2)
    addEdge(adj, 2, 0)

    print("Adjacency List Representation:")
    displayAdjList(adj)


if __name__ == "__main__":
    main()
C# 
using System;
using System.Collections.Generic;

class GfG
{
    // Function to add an edge between two vertices
    static void addEdge(List<List<int>> adj, int u, int v)
    {
        adj[u].Add(v);
    }

    static void displayAdjList(List<List<int>> adj)
    {
        for (int i = 0; i < adj.Count; i++)
        {
            Console.Write(i + ": ");
            foreach (int j in adj[i])
            {
                Console.Write(j + " ");
            }
            Console.WriteLine();
        }
    }

    static void Main(string[] args)
    {
        // Create a graph with 3 vertices and 3 edges
        int V = 3;
        List<List<int>> adj = new List<List<int>>();
        for (int i = 0; i < V; i++)
        {
            adj.Add(new List<int>());
        }

        // Now add edges one by one
        addEdge(adj, 1, 0);
        addEdge(adj, 1, 2);
        addEdge(adj, 2, 0);

        Console.WriteLine("Adjacency List Representation:");
        displayAdjList(adj);
    }
}
JavaScript 
// Function to add an edge between two vertices
function addEdge(adj, u, v) {
    adj[u].push(v);
}


function displayAdjList(adj) {
    for (let i = 0; i < adj.length; i++) {
        let line = i + ": ";
        for (let j of adj[i]) {
            line += j + " ";
        }
        console.log(line);
    }
}


function main() {

    // Create a graph with 3 vertices and 3 edges
    let V = 3;
    let adj = Array.from({ length: V }, () => []);

    // Now add edges one by one
    addEdge(adj, 1, 0);
    addEdge(adj, 1, 2);
    addEdge(adj, 2, 0);

    console.log("Adjacency List Representation:");
    displayAdjList(adj);
}

main();

Output
Adjacency List Representation:
0: 
1: 0 2 
2: 0

2. Adjacency List for Undirected graph:

Consider an Undirected and Unweighted graph G with 3 vertices and 3 edges. For the graph G, the adjacency list would look like:


C++ 
#include <iostream>
#include <vector>
using namespace std;

// Function to add an edge between two vertices
void addEdge(vector<vector<int>>& adj, int u, int v) {
    adj[u].push_back(v);
  	adj[v].push_back(u);
}

void displayAdjList(vector<vector<int>>& adj) {
    for (int i = 0; i < adj.size(); i++) {
        cout << i << ": "; 
        for (int j : adj[i]) {
            cout << j << " "; 
        }
        cout << endl; 
    }
}

int main() {
  
    // Create a graph with 3 vertices and 3 edges
    int V = 3;
    vector<vector<int>> adj(V); 

    // Now add edges one by one
    addEdge(adj, 1, 0);
    addEdge(adj, 1, 2);
    addEdge(adj, 2, 0);

    cout << "Adjacency List Representation:" << endl;
    displayAdjList(adj);

    return 0;
}
Java 
import java.util.ArrayList;
import java.util.List;

class GfG {

    // Function to add an edge between two vertices
    static void addEdge(List<List<Integer>> adj, int u, int v) {
        adj.get(u).add(v);
      	adj.get(v).add(u);
    }

    static void displayAdjList(List<List<Integer>> adj) {
        for (int i = 0; i < adj.size(); i++) {
            System.out.print(i + ": ");
            for (int j : adj.get(i)) {
                System.out.print(j + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
      
        // Create a graph with 3 vertices and 3 edges
        int V = 3;
        List<List<Integer>> adj = new ArrayList<>();

        for (int i = 0; i < V; i++) {
            adj.add(new ArrayList<>());
        }

        // Now add edges one by one
        addEdge(adj, 1, 0);
        addEdge(adj, 1, 2);
        addEdge(adj, 2, 0);

        System.out.println("Adjacency List Representation:");
        displayAdjList(adj);
    }
}
Python 
# Function to add an edge between two vertices
def addEdge(adj, u, v):
    adj[u].append(v)
    adj[v].append(u)

def displayAdjList(adj):
    for i in range(len(adj)):
        print(f"{i}: ", end="")
        for j in adj[i]:
            print(f"{j} ", end="")
        print()


def main():
  
    # Create a graph with 3 vertices and 3 edges
    V = 3
    adj = [[] for _ in range(V)]

    # Now add edges one by one
    addEdge(adj, 1, 0)
    addEdge(adj, 1, 2)
    addEdge(adj, 2, 0)

    print("Adjacency List Representation:")
    displayAdjList(adj)


if __name__ == "__main__":
    main()
C# 
using System;
using System.Collections.Generic;

class GfG
{
    // Function to add an edge between two vertices
    static void addEdge(List<List<int>> adj, int u, int v)
    {
        adj[u].Add(v);
      	adj[v].Add(u);
    }

    static void displayAdjList(List<List<int>> adj)
    {
        for (int i = 0; i < adj.Count; i++)
        {
            Console.Write(i + ": ");
            foreach (int j in adj[i])
            {
                Console.Write(j + " ");
            }
            Console.WriteLine();
        }
    }


    static void Main(string[] args)
    {
        // Create a graph with 3 vertices and 3 edges
        int V = 3;
        List<List<int>> adj = new List<List<int>>();
        for (int i = 0; i < V; i++)
        {
            adj.Add(new List<int>());
        }

        // Now add edges one by one
        addEdge(adj, 1, 0);
        addEdge(adj, 1, 2);
        addEdge(adj, 2, 0);

        Console.WriteLine("Adjacency List Representation:");
        displayAdjList(adj);
    }
}
JavaScript 
// Function to add an edge between two vertices
function addEdge(adj, u, v) {
    adj[u].push(v);
    adj[v].push(u);
}


function displayAdjList(adj) {
    for (let i = 0; i < adj.length; i++) {
        let line = i + ": ";
        for (let j of adj[i]) {
            line += j + " ";
        }
        console.log(line);
    }
}


function main() {

    // Create a graph with 3 vertices and 3 edges
    let V = 3;
    let adj = Array.from({ length: V }, () => []);

    // Now add edges one by one
    addEdge(adj, 1, 0);
    addEdge(adj, 1, 2);
    addEdge(adj, 2, 0);

    console.log("Adjacency List Representation:");
    displayAdjList(adj);
}

main();

Output
Adjacency List Representation:
0: 1 2 
1: 0 2 
2: 1 0

3. Adjacency List for Directed and Weighted graph:

Consider an Directed and Weighted graph G with 3 vertices and 3 edges. For the graph G, the adjacency list would look like:


C++ 
#include <iostream>
#include <vector>
using namespace std;

// Function to add an edge between two vertices
void addEdge(vector<vector<pair<int,int>>>& adj, int u, int v, int w) {
    adj[u].push_back({v,w});
}

void displayAdjList(vector<vector<pair<int,int>>>& adj) {
    for (int i = 0; i < adj.size(); i++) {
        cout << i << ": "; 
        for (auto &j : adj[i]) {
            cout << "{"<<j.first << ", "<<j.second<<"} "; 
        }
        cout << endl; 
    }
}

int main() {
  
    // Create a graph with 3 vertices and 3 edges
    int V = 3;
    vector<vector<pair<int,int>>> adj(V); 

    // Now add edges one by one
    addEdge(adj, 1, 0, 4);
    addEdge(adj, 1, 2, 3);
    addEdge(adj, 2, 0, 1);

    cout << "Adjacency List Representation:" << endl;
    displayAdjList(adj);

    return 0;
}
Java 
import java.util.ArrayList;
import java.util.List;
import java.util.AbstractMap.SimpleEntry;

// Function to add an edge between two vertices
class GfG {
    static void addEdge(List<List<SimpleEntry<Integer, Integer>>> adj, int u, int v, int w) {
        adj.get(u).add(new SimpleEntry<>(v, w));
    }

    static void displayAdjList(List<List<SimpleEntry<Integer, Integer>>> adj) {
        for (int i = 0; i < adj.size(); i++) {
            System.out.print(i + ": "); 
            for (SimpleEntry<Integer, Integer> j : adj.get(i)) {
                System.out.print("{" + j.getKey() + ", " + j.getValue() + "} "); 
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
      
        // Create a graph with 3 vertices and 3 edges
        int V = 3;
        List<List<SimpleEntry<Integer, Integer>>> adj = new ArrayList<>();
        for (int i = 0; i < V; i++) {
            adj.add(new ArrayList<>());
        }

        // Now add edges one by one
        addEdge(adj, 1, 0, 4);
        addEdge(adj, 1, 2, 3);
        addEdge(adj, 2, 0, 1);

        System.out.println("Adjacency List Representation:");
        displayAdjList(adj);
    }
}
Python 
# Function to add an edge between two vertices
def addEdge(adj, u, v, w):
    adj[u].append((v, w))

def displayAdjList(adj):
    for i in range(len(adj)):
        print(f"{i}: ", end="")
        for j in adj[i]:
            print(f"{{{j[0]}, {j[1]}}} ", end="")
        print()

def main():
  
    # Create a graph with 3 vertices and 3 edges
    V = 3
    adj = [[] for _ in range(V)]

    # Now add edges one by one
    addEdge(adj, 1, 0, 4)
    addEdge(adj, 1, 2, 3)
    addEdge(adj, 2, 0, 1)

    print("Adjacency List Representation:")
    displayAdjList(adj)

if __name__ == "__main__":
    main()
C# 
using System;
using System.Collections.Generic;

// Function to add an edge between two vertices
class GfG
{
    static void addEdge(List<List<KeyValuePair<int, int>>> adj, int u, int v, int w)
    {
        adj[u].Add(new KeyValuePair<int, int>(v, w));
    }

    static void displayAdjList(List<List<KeyValuePair<int, int>>> adj)
    {
        for (int i = 0; i < adj.Count; i++)
        {
            Console.Write(i + ": "); 
            foreach (var j in adj[i])
            {
                Console.Write("{" + j.Key + ", " + j.Value + "} "); 
            }
            Console.WriteLine();
        }
    }

    static void Main(string[] args)
    {
        // Create a graph with 3 vertices and 3 edges
        int V = 3;
        List<List<KeyValuePair<int, int>>> adj = new List<List<KeyValuePair<int, int>>>();
        for (int i = 0; i < V; i++)
        {
            adj.Add(new List<KeyValuePair<int, int>>());
        }

        // Now add edges one by one
        addEdge(adj, 1, 0, 4);
        addEdge(adj, 1, 2, 3);
        addEdge(adj, 2, 0, 1);

        Console.WriteLine("Adjacency List Representation:");
        displayAdjList(adj);
    }
}
JavaScript 
// Function to add an edge between two vertices
function addEdge(adj, u, v, w) {
    adj[u].push([v, w]);
}

function displayAdjList(adj) {
    for (let i = 0; i < adj.length; i++) {
        let line = i + ": "; 
        for (let j of adj[i]) {
            line += `{${j[0]}, ${j[1]}} `; 
        }
        console.log(line);
    }
}

function main() {

    // Create a graph with 3 vertices and 3 edges
    let V = 3;
    let adj = Array.from({ length: V }, () => []);

    // Now add edges one by one
    addEdge(adj, 1, 0, 4);
    addEdge(adj, 1, 2, 3);
    addEdge(adj, 2, 0, 1);

    console.log("Adjacency List Representation:");
    displayAdjList(adj);
}

main();

Output
Adjacency List Representation:
0: 
1: {0, 4} {2, 3} 
2: {0, 1}

4. Adjacency List for Undirected and Weighted graph:

Consider an Undirected and Weighted graph G with 3 vertices and 3 edges. For the graph G, the adjacency list would look like:


C++ 
#include <iostream>
#include <vector>
using namespace std;

// Function to add an edge between two vertices
void addEdge(vector<vector<pair<int,int>>>& adj, int u, int v, int w) {
    adj[u].push_back({v,w});
  	adj[v].push_back({u,w});
}

// Function to display the adjacency list
void displayAdjList(vector<vector<pair<int,int>>>& adj) {
    for (int i = 0; i < adj.size(); i++) {
        cout << i << ": "; 
        for (auto &j : adj[i]) {
            cout << "{"<<j.first << ", "<<j.second<<"} "; 
        }
        cout << endl; 
    }
}

int main() {
  
    // Create a graph with 3 vertices and 3 edges
    int V = 3;
    vector<vector<pair<int,int>>> adj(V); 

    // Now add edges one by one
    addEdge(adj, 1, 0, 4);
    addEdge(adj, 1, 2, 3);
    addEdge(adj, 2, 0, 1);

    cout << "Adjacency List Representation:" << endl;
    displayAdjList(adj);

    return 0;
}
Java 
import java.util.ArrayList;
import java.util.List;
import java.util.AbstractMap.SimpleEntry;

// Function to add an edge between two vertices
class GfG {
    static void addEdge(List<List<SimpleEntry<Integer, Integer>>> adj, int u, int v, int w) {
        adj.get(u).add(new SimpleEntry<>(v, w));
        adj.get(v).add(new SimpleEntry<>(u, w));
    }

    static void displayAdjList(List<List<SimpleEntry<Integer, Integer>>> adj) {
        for (int i = 0; i < adj.size(); i++) {
            System.out.print(i + ": "); 
            for (SimpleEntry<Integer, Integer> j : adj.get(i)) {
                System.out.print("{" + j.getKey() + ", " + j.getValue() + "} "); 
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
      
        // Create a graph with 3 vertices and 3 edges
        int V = 3;
        List<List<SimpleEntry<Integer, Integer>>> adj = new ArrayList<>();
        for (int i = 0; i < V; i++) {
            adj.add(new ArrayList<>());
        }

        // Now add edges one by one
        addEdge(adj, 1, 0, 4);
        addEdge(adj, 1, 2, 3);
        addEdge(adj, 2, 0, 1);

        System.out.println("Adjacency List Representation:");
        displayAdjList(adj);
    }
}
Python 
# Function to add an edge between two vertices
def addEdge(adj, u, v, w):
    adj[u].append((v, w))
    adj[v].append((u, w))

def displayAdjList(adj):
    for i in range(len(adj)):
        print(f"{i}: ", end="")
        for j in adj[i]:
            print(f"{{{j[0]}, {j[1]}}} ", end="")
        print()

def main():
  
    # Create a graph with 3 vertices and 3 edges
    V = 3
    adj = [[] for _ in range(V)]

    # Now add edges one by one
    addEdge(adj, 1, 0, 4)
    addEdge(adj, 1, 2, 3)
    addEdge(adj, 2, 0, 1)

    print("Adjacency List Representation:")
    displayAdjList(adj)

if __name__ == "__main__":
    main()
C# 
using System;
using System.Collections.Generic;

// Function to add an edge between two vertices
class GfG
{
    static void addEdge(List<List<KeyValuePair<int, int>>> adj, int u, int v, int w)
    {
        adj[u].Add(new KeyValuePair<int, int>(v, w));
        adj[v].Add(new KeyValuePair<int, int>(u, w));
    }

    static void displayAdjList(List<List<KeyValuePair<int, int>>> adj)
    {
        for (int i = 0; i < adj.Count; i++)
        {
            Console.Write(i + ": "); 
            foreach (var j in adj[i])
            {
                Console.Write("{" + j.Key + ", " + j.Value + "} "); 
            }
            Console.WriteLine();
        }
    }

    static void Main(string[] args)
    {
        // Create a graph with 3 vertices and 3 edges
        int V = 3;
        List<List<KeyValuePair<int, int>>> adj = new List<List<KeyValuePair<int, int>>>();
        for (int i = 0; i < V; i++)
        {
            adj.Add(new List<KeyValuePair<int, int>>());
        }

        // Now add edges one by one
        addEdge(adj, 1, 0, 4);
        addEdge(adj, 1, 2, 3);
        addEdge(adj, 2, 0, 1);

        Console.WriteLine("Adjacency List Representation:");
        displayAdjList(adj);
    }
}
JavaScript 
// Function to add an edge between two vertices
function addEdge(adj, u, v, w) {
    adj[u].push([v, w]);
    adj[v].push([u, w]);
}

function displayAdjList(adj) {
    for (let i = 0; i < adj.length; i++) {
        let line = i + ": "; 
        for (let j of adj[i]) {
            line += `{${j[0]}, ${j[1]}} `; 
        }
        console.log(line);
    }
}

function main() {

    // Create a graph with 3 vertices and 3 edges
    let V = 3;
    let adj = Array.from({ length: V }, () => []);

    // Now add edges one by one
    addEdge(adj, 1, 0, 4);
    addEdge(adj, 1, 2, 3);
    addEdge(adj, 2, 0, 1);

    console.log("Adjacency List Representation:");
    displayAdjList(adj);
}

main();

Output
Adjacency List Representation:
0: {1, 4} {2, 1} 
1: {0, 4} {2, 3} 
2: {1, 3} {0, 1}

Characteristics of the Adjacency List:

  • An adjacency list representation uses a list of lists. We store all adjacent of every node together.
  • The size of the list is determined by the number of vertices in the graph.
  • All adjacent of a vertex are easily available. To find all adjacent, we need only O(n) time where is the number of adjacent vertices.

Applications of the Adjacency List:

Advantages of using an Adjacency list:

  • An adjacency list is simple and easy to understand.
  • Requires less space compared to adjacency matrix for sparse graphs.
  • Easy to traverse through all edges of a graph.
  • Adding an vertex is easier compared to adjacency matrix representation.
  • Most of the graph algorithms are implemented faster with this representation. For example, BFS and DFS implementations take OIV x V) time, but with Adjacency List representation, we get these in linear time. Similarly Prim's and Dijskstra's algorithms are implemented faster with Adjacency List representation.

Disadvantages of using an Adjacency list:

  • Checking if there is an edge between two vertices is costly as we have traverse the adjacency list.
  • Not suitable for dense graphs.

What else can you read?


Next Article
Graph and its representations
author
zaidkhan15
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox