 GeeksforGeeks App
Open App Browser
Continue

# Graph and its representations

Graph is a data structure that consists of the following two components:

• A finite set of vertices also called nodes.
• A finite set of ordered pair of the form (u, v) called edge. The pair is ordered because (u, v) is not the same as (v, u) in the case of a directed graph(di-graph). The pair of the form (u, v) indicates that there is an edge from vertex u to vertex v. The edges may contain weight/value/cost.

Following is an example of an undirected graph with 5 vertices. Example of undirected graph with 5 vertices

Graphs are used to represent many real-life applications: Graphs are used to represent networks. The networks may include paths in a city or telephone network or circuit network. Graphs are also used in social networks like linkedIn, Facebook. For example, in Facebook, each person is represented with a vertex(or node). Each node is a structure and contains information like person id, name, gender, and locale. See this for more applications of graph.

In computer science, a graph is a data structure that is used to represent connections or relationships between objects. A graph consists of a set of vertices (also known as nodes) and a set of edges (also known as arcs) that connect the vertices. The vertices can represent anything from cities in a map to web pages in a network, and the edges can represent the relationships between them, such as roads or links.

A graph can be visualized as a collection of points (vertices) connected by lines (edges), where each vertex represents a point of interest and each edge represents a connection between two points. The edges can be directed or undirected, meaning they can either have a specific direction or be bidirectional. For example, a map of a city may have directed edges that represent the direction of one-way streets, while a social network may have undirected edges that represent friendships between individuals.

### Representations of Graphs:

The following two are the most commonly used representations of a graph.

There are other representations also like, Incidence Matrix and Incidence List. The choice of graph representation is situation-specific. It totally depends on the type of operations to be performed and the ease of use.

```Adjacency List:
An adjacency list is a simple way to represent a graph as a list of vertices, where each vertex has a list of its adjacent vertices. Here's an example of an adjacency list for an undirected graph with 4 vertices:
makefile
Copy code
0: 1 3
1: 0 2
2: 1 3
3: 0 2
In this example, vertex 0 is adjacent to vertices 1 and 3, vertex 1 is adjacent to vertices 0 and 2, and so on.

An adjacency matrix is a two-dimensional array that represents the graph by storing a 1 at position (i,j) if there is an edge from vertex i to vertex j, and 0 otherwise. Here's an example of an adjacency matrix for the same undirected graph:
Copy code
0 1 2 3
0 0 1 0 1
1 1 0 1 0
2 0 1 0 1
3 1 0 1 0
In this example, there is an edge from vertex 0 to vertex 1 (represented by a 1 in position (0,1)), an edge from vertex 1 to vertex 0 (represented by a 1 in position (1,0)), and so on.

Incidence Matrix:
An incidence matrix is a two-dimensional array that represents the graph by storing a 1 at position (i,j) if vertex i is incident on edge j, and 0 otherwise. Here's an example of an incidence matrix for the same undirected graph:
Copy code
0 1 2 3
0 1 1 0 1
1 1 0 1 0
2 0 1 1 0
3 1 0 0 1
In this example, vertex 0 is incident on edges 0, 1, and 3 (represented by a 1 in positions (0,0), (0,1), and (0,3)), vertex 1 is incident on edges 0, 2 (represented by a 1 in positions (1,0) and (1,2)), and so on.

Each representation has its own advantages and disadvantages depending on the application, and choosing the right representation can have a significant impact on the performance of graph algorithms.```

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. The adjacency matrix for an undirected graph is always symmetric.

Adjacency Matrix is also used to represent weighted graphs. If adj[i][j] = w, then there is an edge from vertex i to vertex j with weight w

We follow the below pattern to use the adjacency matrix in code:

• In the case of an undirected graph, we need to show that there is an edge from vertex i to vertex j and vice versa. In code, we assign adj[i][j] = 1  and adj[j][i] = 1.
• In the case of a directed graph, if there is an edge from vertex i to vertex j then we just assign adj[i][j]=1.\

See the undirected graph shown below: Example of undirected graph with 5 vertices

The adjacency matrix for the above example graph is: • Representation is easier to implement and follow.
• Removing an edge takes O(1) time.
• Queries like whether there is an edge from vertex ‘u’ to vertex ‘v’ are efficient and can be done O(1).

• Consumes more space O(V2). Even if the graph is sparse(contains less number of edges), it consumes the same space.
• Adding a vertex takes O(V2) time. Computing all neighbors of a vertex takes O(V) time (Not efficient).

## C

 `#include ` `int` `main()``{``    ``// n is the number of vertices``    ``// m is the number of edges``    ``int` `n, m;``    ``scanf``(``"%d %d"``, &n, &m);``    ``int` `adjMat[n + 1][n + 1];``    ``for` `(``int` `i = 0; i < m; i++) {``        ``int` `u, v;``        ``scanf``(``"%d %d"``, &u, &v);``        ``adjMat[u][v] = 1;``        ``adjMat[v][u] = 1;``        ``// for a directed graph with an edge pointing from u``        ``// to v,we just assign adjMat[u][v] as 1``    ``}` `    ``return` `0;``}`

## C++

 `#include ``using` `namespace` `std;` `int` `main()``{``    ``// n is the number of vertices``    ``// m is the number of edges``    ``int` `n, m;``    ``cin >> n >> m;``    ``int` `adjMat[n + 1][n + 1];``    ``for` `(``int` `i = 0; i < m; i++) {``        ``int` `u, v;``        ``cin >> u >> v;``        ``adjMat[u][v] = 1;``        ``adjMat[v][u] = 1;``        ``// for a directed graph with an edge pointing from u``        ``// to v,we just assign adjMat[u][v] as 1``    ``}` `    ``return` `0;``}`

## Java

 `import` `java.util.*;` `public` `class` `Main {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``Scanner sc = ``new` `Scanner(System.in);` `        ``// n is the number of vertices``        ``// m is the number of edges``        ``int` `n = sc.nextInt();``        ``int` `m = sc.nextInt();``        ``int``[][] adjMat = ``new` `int``[n + ``1``][n + ``1``];``        ``for` `(``int` `i = ``0``; i < m; i++) {``            ``int` `u = sc.nextInt();``            ``int` `v = sc.nextInt();``            ``adjMat[u][v] = ``1``;``            ``adjMat[v][u] = ``1``;``            ``// for a directed graph with an edge pointing``            ``// from u to v,we just assign adjMat[u][v] as 1``        ``}``    ``}``}` `// This code is contributed by Tapesh(tapeshdua420)`

## Python3

 `if` `__name__ ``=``=` `'__main__'``:``    ` `    ``#  n is the number of vertices``    ``#  m is the number of edges``    ``n, m ``=` `map``(``int``, ``input``().split())``    ``adjMat ``=` `[[``0` `for` `i ``in` `range``(n)]``for` `j ``in` `range``(n)]``    ``for` `i ``in` `range``(n):``        ``u, v ``=` `map``(``int``, ``input``().split())``        ``adjMat[u][v] ``=` `1``        ``adjMat[v][u] ``=` `1``        ``# for a directed graph with an edge``        ``# pointing from u to v,we just assign``        ``# adjMat[u][v] as 1`

## C#

 `using` `System;``using` `System.IO;` `class` `Program {``    ``static` `void` `Main(``string``[] args)``    ``{``        ``// n is the number of vertices``        ``// m is the number of edges``        ``int` `n, m;``        ``n = Convert.ToInt32(Console.ReadLine());``        ``m = Convert.ToInt32(Console.ReadLine());` `        ``int``[, ] adjMat = ``new` `int``[n + 1, n + 1];` `        ``for` `(``int` `i = 0; i < m; i++) {``            ``int` `u, v;``            ``u = Convert.ToInt32(Console.ReadLine());``            ``v = Convert.ToInt32(Console.ReadLine());` `            ``adjMat[u, v] = 1;``            ``adjMat[v, u] = 1;``            ``// for a directed graph with an edge pointing``            ``// from u to v,we just assign adjMat[u][v] as 1``        ``}``    ``}``}` `// This code is contributed by Tapesh(tapeshdua420)`

## Javascript

 `var` `n;``    ``n = prompt();``    ``var` `m;``    ``m = prompt();``    ` `    ``var` `adjMat = ``new` `Array(n+1);``    ``for``(let i = 0; i < adjMat.length; i++){``        ``adjMat[i] = ``new` `Array(n+1);``    ``}``    ` `    ``for``(let i = 0; i < m; i++){``        ``var` `u = prompt();``        ``var` `v = prompt();``        ``adjMat[u][v] = 1;``        ``adjMat[v][u] = 1;``        ``// for a directed graph with an edge pointing from u to v,we just assign``        ``// adjMat[u][v] as 1``    ``}` `    ``// This code is contributed by lokesh.`

An array of linked 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 linked list of vertices adjacent to the ith vertex.

This representation can also be used to represent a weighted graph. The weights of edges can be represented as lists of pairs.

Recommended Practice

Consider the following graph: Example of undirected graph with 5 vertices

Following is the adjacency list representation of the above graph. Adjacency List representation of the above graph

• Saves space. Space taken is O(|V|+|E|). In the worst case, there can be C(V, 2) number of edges in a graph thus consuming O(V2) space.
• Adding a vertex is easier.
• Computing all neighbors of a vertex takes optimal time.

Queries like whether there is an edge from vertex u to vertex v are not efficient and can be done O(V).

Note that in the below implementation, we use dynamic arrays (vector in C++/ArrayList in Java) to represent adjacency lists instead of the linked list. The vector implementation has the advantage of cache friendliness.

## C

 `// A C Program to demonstrate adjacency list``// representation of graphs``#include ``#include ` `// A structure to represent an adjacency list node``struct` `AdjListNode {``    ``int` `dest;``    ``struct` `AdjListNode* next;``};` `// A structure to represent an adjacency list``struct` `AdjList {``    ``struct` `AdjListNode* head;``};` `// A structure to represent a graph. A graph``// is an array of adjacency lists.``// Size of array will be V (number of vertices``// in graph)``struct` `Graph {``    ``int` `V;``    ``struct` `AdjList* array;``};` `// A utility function to create a new adjacency list node``struct` `AdjListNode* newAdjListNode(``int` `dest)``{``    ``struct` `AdjListNode* newNode``        ``= (``struct` `AdjListNode*)``malloc``(``            ``sizeof``(``struct` `AdjListNode));``    ``newNode->dest = dest;``    ``newNode->next = NULL;``    ``return` `newNode;``}` `// A utility function that creates a graph of V vertices``struct` `Graph* createGraph(``int` `V)``{``    ``struct` `Graph* graph``        ``= (``struct` `Graph*)``malloc``(``sizeof``(``struct` `Graph));``    ``graph->V = V;` `    ``// Create an array of adjacency lists.  Size of``    ``// array will be V``    ``graph->array = (``struct` `AdjList*)``malloc``(``        ``V * ``sizeof``(``struct` `AdjList));` `    ``// Initialize each adjacency list as empty by``    ``// making head as NULL``    ``int` `i;``    ``for` `(i = 0; i < V; ++i)``        ``graph->array[i].head = NULL;` `    ``return` `graph;``}` `// Adds an edge to an undirected graph``void` `addEdge(``struct` `Graph* graph, ``int` `src, ``int` `dest)``{``    ``// Add an edge from src to dest.  A new node is``    ``// added to the adjacency list of src.  The node``    ``// is added at the beginning``    ``struct` `AdjListNode* check = NULL;``    ``struct` `AdjListNode* newNode = newAdjListNode(dest);` `    ``if` `(graph->array[src].head == NULL) {``        ``newNode->next = graph->array[src].head;``        ``graph->array[src].head = newNode;``    ``}``    ``else` `{` `        ``check = graph->array[src].head;``        ``while` `(check->next != NULL) {``            ``check = check->next;``        ``}``        ``// graph->array[src].head = newNode;``        ``check->next = newNode;``    ``}` `    ``// Since graph is undirected, add an edge from``    ``// dest to src also``    ``newNode = newAdjListNode(src);``    ``if` `(graph->array[dest].head == NULL) {``        ``newNode->next = graph->array[dest].head;``        ``graph->array[dest].head = newNode;``    ``}``    ``else` `{``        ``check = graph->array[dest].head;``        ``while` `(check->next != NULL) {``            ``check = check->next;``        ``}``        ``check->next = newNode;``    ``}` `    ``// newNode = newAdjListNode(src);``    ``// newNode->next = graph->array[dest].head;``    ``// graph->array[dest].head = newNode;``}` `// A utility function to print the adjacency list``// representation of graph``void` `printGraph(``struct` `Graph* graph)``{``    ``int` `v;``    ``for` `(v = 0; v < graph->V; ++v) {``        ``struct` `AdjListNode* pCrawl = graph->array[v].head;``        ``printf``(``"\n Adjacency list of vertex %d\n head "``, v);``        ``while` `(pCrawl) {``            ``printf``(``"-> %d"``, pCrawl->dest);``            ``pCrawl = pCrawl->next;``        ``}``        ``printf``(``"\n"``);``    ``}``}` `// Driver program to test above functions``int` `main()``{``    ``// create the graph given in above figure``    ``int` `V = 5;``    ``struct` `Graph* graph = createGraph(V);``    ``addEdge(graph, 0, 1);``    ``addEdge(graph, 0, 4);``    ``addEdge(graph, 1, 2);``    ``addEdge(graph, 1, 3);``    ``addEdge(graph, 1, 4);``    ``addEdge(graph, 2, 3);``    ``addEdge(graph, 3, 4);` `    ``// print the adjacency list representation of the above``    ``// graph``    ``printGraph(graph);` `    ``return` `0;``}`

## C++

 `// A simple representation of graph using STL``#include ``using` `namespace` `std;` `// A utility function to add an edge in an``// undirected graph.``void` `addEdge(vector<``int``> adj[], ``int` `u, ``int` `v)``{``    ``adj[u].push_back(v);``    ``adj[v].push_back(u);``}` `// A utility function to print the adjacency list``// representation of graph``void` `printGraph(vector<``int``> adj[], ``int` `V)``{``    ``for` `(``int` `v = 0; v < V; ++v) {``        ``cout << ``"\n Adjacency list of vertex "` `<< v``             ``<< ``"\n head "``;``        ``for` `(``auto` `x : adj[v])``            ``cout << ``"-> "` `<< x;``        ``cout << endl;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `V = 5;``    ``vector<``int``> adj[V];``    ``addEdge(adj, 0, 1);``    ``addEdge(adj, 0, 4);``    ``addEdge(adj, 1, 2);``    ``addEdge(adj, 1, 3);``    ``addEdge(adj, 1, 4);``    ``addEdge(adj, 2, 3);``    ``addEdge(adj, 3, 4);``    ``printGraph(adj, V);``    ``return` `0;``}`

## Java

 `// Java code to demonstrate Graph representation``// using ArrayList in Java` `import` `java.util.*;` `class` `Graph {` `    ``// A utility function to add an edge in an``    ``// undirected graph``    ``static` `void` `addEdge(ArrayList > adj,``                        ``int` `u, ``int` `v)``    ``{``        ``adj.get(u).add(v);``        ``adj.get(v).add(u);``        ``// for a directed graph with an edge pointing from u``        ``// to v, adj.get(u).add(v);``    ``}` `    ``// A utility function to print the adjacency list``    ``// representation of graph``    ``static` `void``    ``printGraph(ArrayList > adj)``    ``{``        ``for` `(``int` `i = ``0``; i < adj.size(); i++) {``            ``System.out.println(``"\nAdjacency list of vertex"``                               ``+ i);``            ``System.out.print(``"head"``);``            ``for` `(``int` `j = ``0``; j < adj.get(i).size(); j++) {``                ``System.out.print(``" -> "``                                 ``+ adj.get(i).get(j));``            ``}``            ``System.out.println();``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Creating a graph with 5 vertices``        ``int` `V = ``5``;``        ``ArrayList > adj``            ``= ``new` `ArrayList >(V);` `        ``for` `(``int` `i = ``0``; i < V; i++)``            ``adj.add(``new` `ArrayList());` `        ``// Adding edges one by one``        ``addEdge(adj, ``0``, ``1``);``        ``addEdge(adj, ``0``, ``4``);``        ``addEdge(adj, ``1``, ``2``);``        ``addEdge(adj, ``1``, ``3``);``        ``addEdge(adj, ``1``, ``4``);``        ``addEdge(adj, ``2``, ``3``);``        ``addEdge(adj, ``3``, ``4``);` `        ``printGraph(adj);``    ``}``}`

## Python3

 `"""``A Python program to demonstrate the adjacency``list representation of the graph``"""`  `# A class to represent the adjacency list of the node``class` `AdjNode:``    ``def` `__init__(``self``, data):``        ``self``.vertex ``=` `data``        ``self``.``next` `=` `None`  `# A class to represent a graph. A graph``# is the list of the adjacency lists.``# Size of the array will be the no. of the``# vertices "V"``class` `Graph:``    ``def` `__init__(``self``, vertices):``        ``self``.V ``=` `vertices``        ``self``.graph ``=` `[``None``] ``*` `self``.V` `    ``# Function to add an edge in an undirected graph``    ``def` `add_edge(``self``, src, dest):``        ``# Adding the node to the source node``        ``node ``=` `AdjNode(dest)``        ``node.``next` `=` `self``.graph[src]``        ``self``.graph[src] ``=` `node` `        ``# Adding the source node to the destination as``        ``# it is the undirected graph``        ``node ``=` `AdjNode(src)``        ``node.``next` `=` `self``.graph[dest]``        ``self``.graph[dest] ``=` `node` `    ``# Function to print the graph``    ``def` `print_graph(``self``):``        ``for` `i ``in` `range``(``self``.V):``            ``print``(``"Adjacency list of vertex {}\n head"``.``format``(i), end``=``"")``            ``temp ``=` `self``.graph[i]``            ``while` `temp:``                ``print``(``" -> {}"``.``format``(temp.vertex), end``=``"")``                ``temp ``=` `temp.``next``            ``print``(``" \n"``)`  `# Driver program to the above graph class``if` `__name__ ``=``=` `"__main__"``:``    ``V ``=` `5``    ``graph ``=` `Graph(V)``    ``graph.add_edge(``0``, ``1``)``    ``graph.add_edge(``0``, ``4``)``    ``graph.add_edge(``1``, ``2``)``    ``graph.add_edge(``1``, ``3``)``    ``graph.add_edge(``1``, ``4``)``    ``graph.add_edge(``2``, ``3``)``    ``graph.add_edge(``3``, ``4``)` `    ``graph.print_graph()` `# This code is contributed by Kanav Malhotra`

## C#

 `// C# code to demonstrate Graph representation``// using LinkedList in C#``using` `System;``using` `System.Collections.Generic;` `class` `Graph {``    ``// A utility function to add an edge in an``    ``// undirected graph``    ``static` `void` `addEdge(LinkedList<``int``>[] adj, ``int` `u, ``int` `v)``    ``{``        ``adj[u].AddLast(v);``        ``adj[v].AddLast(u);``    ``}` `    ``// A utility function to print the adjacency list``    ``// representation of graph``    ``static` `void` `printGraph(LinkedList<``int``>[] adj)``    ``{``        ``for` `(``int` `i = 0; i < adj.Length; i++) {``            ``Console.WriteLine(``"\nAdjacency list of vertex "``                              ``+ i);``            ``Console.Write(``"head"``);` `            ``foreach``(``var` `item ``in` `adj[i])``            ``{``                ``Console.Write(``" -> "` `+ item);``            ``}``            ``Console.WriteLine();``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``// Creating a graph with 5 vertices``        ``int` `V = 5;``        ``LinkedList<``int``>[] adj = ``new` `LinkedList<``int``>[ V ];` `        ``for` `(``int` `i = 0; i < V; i++)``            ``adj[i] = ``new` `LinkedList<``int``>();` `        ``// Adding edges one by one``        ``addEdge(adj, 0, 1);``        ``addEdge(adj, 0, 4);``        ``addEdge(adj, 1, 2);``        ``addEdge(adj, 1, 3);``        ``addEdge(adj, 1, 4);``        ``addEdge(adj, 2, 3);``        ``addEdge(adj, 3, 4);` `        ``printGraph(adj);` `        ``Console.ReadKey();``    ``}``}` `// This code is contributed by techno2mahi`

## Javascript

 ``

Output

``` Adjacency list of vertex 0

head -> 0-> 2-> 3-> 4