Prerequisite: Graph and its representations
Examples:

Input: arr[][] = [ [0, 0, 1], [0, 0, 1], [1, 1, 0] ]
0 -> 2
1 -> 2
2 -> 0 -> 1

Input: arr[][] = [ [0, 1, 0, 0, 1], [1, 0, 1, 1, 1], [0, 1, 0, 1, 0], [0, 1, 1, 0, 1], [1, 1, 0, 1, 0] ]
0 -> 1 -> 4
1 -> 0 -> 2 -> 3 -> 4
2 -> 1 -> 3
3 -> 1 -> 2 -> 4
4 -> 0 -> 1 -> 3

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Adjacency Matrix: 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.

Adjacency List: An array of lists is used. The size of the array is equal to the number of vertices. Let the array be array[]. An entry array[i] represents the list of vertices adjacent to the ith vertex.

To convert an adjacency matrix to the adjacency list. Create an array of lists and traverse the adjacency matrix. If for any cell (i, j) in the matrix “mat[i][j] = 1“, it means there is an edge from i to j, so insert j in the list at i-th position in the array of lists.

Below is the implementation of the above approach:

## C++

 `#include ` `using` `namespace` `std; ` ` `  `// CPP program to convert Adjacency matrix ` `// representation to Adjacency List ` ` `  `// converts from adjacency matrix to adjacency list ` `vector> convert( vector> a) ` `{ ` `    ``vector> adjList(a.size()); ` `    ``for` `(``int` `i = 0; i < a.size(); i++) ` `    ``{ ` `         `  `        ``for` `(``int` `j = 0; j < a[i].size(); j++) ` `        ``{ ` `            ``if` `(a[i][j] == 1) ` `            ``{ ` `                ``adjList[i].push_back(j); ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `adjList; ` `} ` `     `  `// Driver code ` `int` `main() ` `{ ` `    ``vector> a; ` `    ``vector<``int``> p({0, 0, 1}); ` `    ``vector<``int``> q({0, 0, 1}); ` `    ``vector<``int``> r({1, 1, 0}); ``// adjacency matrix ` `    ``a.push_back(p); ` `    ``a.push_back(q); ` `    ``a.push_back(r); ` `    ``vector> AdjList = convert(a); ` `    ``cout<<``"Adjacency List:"``< "` `<< AdjList[i][j] << endl; ` `                ``break``; ` `            ``} ` `            ``else` `                ``cout << ``" -> "` `<< AdjList[i][j]; ` `        ``} ` `    ``} ` `} ` ` `  `// This code is contributed by Surendra_Gangwar `

## Java

 `// Java program to convert adjacency ` `// matrix representation to ` `// adjacency list ` `import` `java.util.*; ` ` `  `public` `class` `GFG { ` ` `  `    ``// Function to convert adjacency ` `    ``// list to adjacency matrix ` `    ``static` `ArrayList> convert(``int``[][] a) ` `    ``{ ` `        ``// no of vertices ` `        ``int` `l = a[``0``].length; ` `        ``ArrayList> adjListArray  ` `        ``= ``new` `ArrayList>(l); ` ` `  `        ``// Create a new list for each ` `        ``// vertex such that adjacent ` `        ``// nodes can be stored ` `        ``for` `(``int` `i = ``0``; i < l; i++) { ` `            ``adjListArray.add(``new` `ArrayList()); ` `        ``} ` `         `  `        ``int` `i, j; ` `        ``for` `(i = ``0``; i < a[``0``].length; i++) { ` `            ``for` `(j = ``0``; j < a.length; j++) { ` `                ``if` `(a[i][j] == ``1``) { ` `                    ``adjListArray.get(i).add(j); ` `                ``} ` `            ``} ` `        ``} ` `         `  `        ``return` `adjListArray; ` `    ``} ` `     `  `    ``// Function to print the adjacency list ` `    ``static` `void` `printArrayList(ArrayList>  ` `                                                ``adjListArray) ` `    ``{ ` `        ``// Print the adjacency list ` `        ``for` `(``int` `v = ``0``; v < adjListArray.size(); v++) { ` `            ``System.out.print(v); ` `            ``for` `(Integer u : adjListArray.get(v)) { ` `                ``System.out.print(``" -> "` `+ u); ` `            ``} ` `            ``System.out.println(); ` `        ``} ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``// Given Adjacency Matrix ` `        ``int``[][] a = { { ``0``, ``0``, ``1` `}, ` `                    ``{ ``0``, ``0``, ``1` `}, ` `                    ``{ ``1``, ``1``, ``0` `} }; ` ` `  `        ``// function to convert adjacency ` `        ``// list to adjacency matrix ` `        ``ArrayList> adjListArray = convert(a); ` `        ``System.out.println(``"Adjacency List: "``); ` ` `  `        ``printArrayList(adjListArray); ` `    ``} ` `} `

## Python

 `# Python program to convert Adjacency matrix ` `# representation to Adjacency List ` ` `  `from` `collections ``import` `defaultdict ` `# converts from adjacency matrix to adjacency list ` `def` `convert(a): ` `    ``adjList ``=` `defaultdict(``list``) ` `    ``for` `i ``in` `range``(``len``(a)): ` `        ``for` `j ``in` `range``(``len``(a[i])): ` `                       ``if` `a[i][j]``=``=` `1``: ` `                           ``adjList[i].append(j) ` `    ``return` `adjList ` ` `  `# driver code ` `a ``=``[[``0``, ``0``, ``1``], [``0``, ``0``, ``1``], [``1``, ``1``, ``0``]] ``# adjacency matrix ` `AdjList ``=` `convert(a) ` `print``(``"Adjacency List:"``) ` `# print the adjacency list ` `for` `i ``in` `AdjList: ` `    ``print``(i, end ``=``"") ` `    ``for` `j ``in` `AdjList[i]: ` `        ``print``(``" -> {}"``.``format``(j), end ``=``"") ` `    ``print``() ` `  `  `# This code is contributed by Muskan Kalra. `

## C#

 `// C# program to convert adjacency ` `// matrix representation to ` `// adjacency list ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// Function to convert adjacency ` `    ``// list to adjacency matrix ` `    ``static` `List> convert(``int``[,] a) ` `    ``{ ` `        ``// no of vertices ` `        ``int` `l = a.GetLength(0); ` `        ``List> adjListArray = ``new` `List>(l); ` `        ``int` `i, j; ` `         `  `        ``// Create a new list for each ` `        ``// vertex such that adjacent ` `        ``// nodes can be stored ` `        ``for` `(i = 0; i < l; i++)  ` `        ``{ ` `            ``adjListArray.Add(``new` `List<``int``>()); ` `        ``} ` ` `  `         `  `        ``for` `(i = 0; i < a.GetLength(0); i++)  ` `        ``{ ` `            ``for` `(j = 0; j < a.GetLength(1); j++) ` `            ``{ ` `                ``if` `(a[i,j] == 1)  ` `                ``{ ` `                    ``adjListArray[i].Add(j); ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``return` `adjListArray; ` `    ``} ` ` `  `    ``// Function to print the adjacency list ` `    ``static` `void` `printList(List> adjListArray)  ` `    ``{ ` `         `  `        ``// Print the adjacency list ` `        ``for` `(``int` `v = 0; v < adjListArray.Count; v++)  ` `        ``{ ` `            ``Console.Write(v); ` `            ``foreach` `(``int` `u ``in` `adjListArray[v]) ` `            ``{ ` `                ``Console.Write(``" -> "` `+ u); ` `            ``} ` `            ``Console.WriteLine(); ` `        ``} ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `         `  `        ``// Given Adjacency Matrix ` `        ``int``[,] a = { { 0, 0, 1 }, { 0, 0, 1 }, { 1, 1, 0 } }; ` ` `  `        ``// function to convert adjacency ` `        ``// list to adjacency matrix ` `        ``List> adjListArray = convert(a); ` `        ``Console.WriteLine(``"Adjacency List: "``); ` ` `  `        ``printList(adjListArray); ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```Adjacency List:
0 -> 2
1 -> 2
2 -> 0 -> 1
```

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.
{"found_math": false, "script_math_tex": 0, "script_math_asciimath": 0, "math_annotations": 0, "math_alttext": 0, "mathml": 0, "mathjax_tag": 0, "mathjax_inline_tex": 0, "mathjax_display_tex": 0, "mathjax_asciimath": 0, "img_math": 0, "codecogs_latex": 0, "wp_latex": 0, "mimetex.cgi": 0, "/images/math/codecogs": 0, "mathtex.cgi": 0, "katex": 0, "math-container": 0, "wp-katex-eq": 0, "align": 0, "equation": 0, "x-ck12": 0, "texerror": 0}