Adjacency List Representation (original) (raw)

Last Updated : 23 Jul, 2025

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:
• 2. Adjacency List for Undirected graph:
• 3. Adjacency List for Directed and Weighted graph:
• 4. Adjacency List for Undirected and Weighted graph:
• Characteristics of the Adjacency List:
• Applications of the Adjacency List:
• Advantages of using an Adjacency list:
• Disadvantages of using an Adjacency list:

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 #include using namespace std;

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

void displayAdjList(const vector<vector>& 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> 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 #include using namespace std;

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

void displayAdjList(vector<vector>& 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> 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 #include 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 #include 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:

• Graph algorithms: Many graph algorithms like Dijkstra's algorithm, Breadth First Search, and Depth First Search perform faster for adjacency lists to represent graphs.
• Adjacency List representation is the most commonly used representation of graph as it allows easy traversal of all edges.

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?

• Adjacency Matrix meaning and definition in DSA
• Add and Remove Edge in Adjacency List representation of a Graph
• Convert Adjacency Matrix to Adjacency List representation of Graph
• Convert Adjacency List to Adjacency Matrix representation of a Graph
• Comparison between Adjacency List and Adjacency Matrix representation of Graph