Adjacency List Representation
Last Updated :
07 Nov, 2024
Improve
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:
#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;
}
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);
}
}
# 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()
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);
}
}
// 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:
#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;
}
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);
}
}
# 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()
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);
}
}
// 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:
#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;
}
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);
}
}
# 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()
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);
}
}
// 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:
#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;
}
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);
}
}
# 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()
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);
}
}
// 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
