# Construct a linked list from 2D matrix (Iterative Approach)

• Difficulty Level : Medium
• Last Updated : 08 Feb, 2023

Given a matrix, the task is to construct a linked list matrix in which each node is connected to its right and down node.

Example:

```Input: [1 2 3
4 5 6
7 8 9]

Output:
1 -> 2 -> 3 -> NULL
|    |    |
v    v    v
4 -> 5 -> 6 -> NULL
|    |    |
v    v    v
7 -> 8 -> 9 -> NULL
|    |    |
v    v    v
NULL NULL NULL```

A recursive solution for this problem has been already discussed in this post. Below is an iterative approach for the problem:

• The idea is to create m linked lists (m = number of rows) whose each node stores its right node. The head pointers of each m linked lists are stored in an array of nodes.
• Then, traverse m lists, for every ith and (i+1)th list, set the down pointers of each node of ith list to its corresponding node of (i+1)th list.

Below is the implementation of the above approach:

## C++

 `// C++ program to construct a linked``// list from 2D matrix | Iterative Approach``#include ``using` `namespace` `std;` `// struct node of linked list``struct` `node {``    ``int` `data;``    ``node *right, *down;``};` `// utility function to create a new node with given data``node* newNode(``int` `d)``{``    ``node* temp = ``new` `node;``    ``temp->data = d;``    ``temp->right = temp->down = NULL;``    ``return` `temp;``}` `// utility function to print the linked list pointed to by head pointer``void` `display(node* head)``{``    ``node *rp, *dp = head;` `    ``// loop until the down pointer is not NULL``    ``while` `(dp) {``        ``rp = dp;` `        ``// loop until the right pointer is not NULL``        ``while` `(rp) {``            ``cout << rp->data << ``" "``;``            ``rp = rp->right;``        ``}``        ``cout << endl;``        ``dp = dp->down;``    ``}``}` `// function which constructs the linked list``// from the given matrix of size m * n``// and returns the head pointer of the linked list``node* constructLinkedMatrix(``int` `mat[][3], ``int` `m, ``int` `n)``{``    ``// stores the head of the linked list``    ``node* mainhead = NULL;` `    ``// stores the head of linked lists of each row``    ``node* head[m];``    ``node *righttemp, *newptr;` `    ``// Firstly, we create m linked lists``    ``// by setting all the right nodes of every row``    ``for` `(``int` `i = 0; i < m; i++) {` `        ``// initially set the head of ith row as NULL``        ``head[i] = NULL;``        ``for` `(``int` `j = 0; j < n; j++) {``            ``newptr = newNode(mat[i][j]);` `            ``// stores the mat[0][0] node as``            ``// the mainhead of the linked list``            ``if` `(!mainhead)``                ``mainhead = newptr;` `            ``if` `(!head[i])``                ``head[i] = newptr;``            ``else``                ``righttemp->right = newptr;` `            ``righttemp = newptr;``        ``}``    ``}` `    ``// Then, for every ith and (i+1)th list,``    ``// we set the down pointers of``    ``// every node of ith list``    ``// with its corresponding``    ``// node of (i+1)th list``    ``for` `(``int` `i = 0; i < m - 1; i++) {` `        ``node *temp1 = head[i], *temp2 = head[i + 1];` `        ``while` `(temp1 && temp2) {` `            ``temp1->down = temp2;``            ``temp1 = temp1->right;``            ``temp2 = temp2->right;``        ``}``    ``}` `    ``// return the mainhead pointer of the linked list``    ``return` `mainhead;``}` `// Driver program to test the above function``int` `main()``{``    ``int` `m, n; ``// m = rows and n = columns``    ``m = 3, n = 3;``    ``// 2D matrix``    ``int` `mat[][3] = { { 1, 2, 3 },``                     ``{ 4, 5, 6 },``                     ``{ 7, 8, 9 } };` `    ``node* head = constructLinkedMatrix(mat, m, n);``    ``display(head);` `    ``return` `0;``}`

## Java

 `// Java implementation for above approach` `// Construct a Linked List from 2-D Matrix``class` `LinkedMatrix``{``    ``class` `Node``    ``{``        ``int` `data;``        ``Node right, down;` `        ``// Default Constructor``        ``Node()``        ``{``            ``this``.right = ``null``;``            ``this``.down = ``null``;``        ``}` `        ``Node(``int` `d)``        ``{``            ``this``.data = d;``            ``this``.right = ``null``;``            ``this``.down = ``null``;``        ``}``    ``}` `    ``/*``    ``A function to construct a Linked List``    ``from the given matrix of size m * n``    ``and returns the head pointer of the linked list``    ``*/``    ``Node constructLinkedMatrix(``int``[][] arr,``                               ``int` `m, ``int` `n)``    ``{` `        ``// stores the head of the linked list``        ``Node mainHead = ``null``;` `        ``// stores the head of linked lists``        ``// of each row``        ``Node[] head = ``new` `Node[m];``        ``Node rightTemp = ``new` `Node(), newptr;` `        ``// Firstly, we create m linked lists``        ``// by setting all the right nodes of every row``        ``for``(``int` `i = ``0``; i < m; i++)``        ``{` `            ``// initially set the head of``            ``// ith row as NULL``            ``head[i] = ``null``;` `            ``for``(``int` `j = ``0``; j < n; j++)``            ``{``                ``newptr = ``new` `Node(arr[i][j]);` `                ``// stores the mat[0][0] node as``                ``// the mainhead of the linked list``                ``if``(mainHead == ``null``)``                    ``mainHead = newptr;``                ``if``(head[i] == ``null``)``                    ``head[i] = newptr;``                ``else``                    ``rightTemp.right = newptr;` `                ``rightTemp = newptr;``            ``}``        ``}` `        ``// Then, for every ith and (i+1)th list,``        ``// we set the down pointers of``        ``// every node of ith list``        ``// with its corresponding``        ``// node of (i+1)th list``        ``for``(``int` `i = ``0``; i < m - ``1``; i++)``        ``{``            ``Node temp1 = head[i], temp2 = head[i + ``1``];` `            ``while``(temp1 != ``null` `&& temp2 != ``null``)``            ``{``                ``temp1.down = temp2;``                ``temp1 = temp1.right;``                ``temp2 = temp2.right;``            ``}``        ``}` `        ``// return the mainhead pointer``        ``// of the linked list``        ``return` `mainHead;``    ``}` `    ``// utility function to print the``    ``// linked list pointed to by head pointer``    ``void` `display(Node head)``    ``{``        ``Node rp, dp = head;` `        ``// loop until the down pointer``        ``// is not NULL``        ``while``(dp != ``null``)``        ``{``            ``rp = dp;` `            ``// loop until the right pointer``            ``// is not NULL``            ``while``(rp != ``null``)``            ``{``                ``System.out.print(rp.data + ``" "``);``                ``rp = rp.right;``            ``}``            ``System.out.println();``            ``dp = dp.down;``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``LinkedMatrix Obj = ``new` `LinkedMatrix();``        ``int` `m = ``3``, n = ``3``; ``// m = rows and n = columns` `        ``// 2-D Matrix``        ``int``[][] arr = {{ ``1``, ``2``, ``3` `},``                       ``{ ``4``, ``5``, ``6` `},``                       ``{ ``7``, ``8``, ``9` `}};` `        ``Node head = Obj.constructLinkedMatrix(arr, m, n);``        ``Obj.display(head);``    ``}``}` `// This code is contributed by Rhythem`

## Python3

 `# Python3 program to construct a linked``# list from 2D matrix | Iterative Approach`` ` `# struct node of linked list``class` `node:   ``    ``def` `__init__(``self``, data):       ``        ``self``.data ``=` `data``        ``self``.right ``=` `None``        ``self``.down ``=` `None`` ` `# utility function to create a new node with given data``def` `newNode(d):``    ``temp ``=` `node(d)``    ``return` `temp;`` ` `# utility function to print the linked list pointed to by head pointer``def` `display(head):``    ``rp ``=` `None``    ``dp ``=` `head;`` ` `    ``# loop until the down pointer is not None``    ``while` `(dp !``=` `None``):       ``        ``rp ``=` `dp;`` ` `        ``# loop until the right pointer is not None``        ``while` `rp !``=` `None``:          ``            ``print``(rp.data, end ``=` `' '``)``            ``rp ``=` `rp.right;``        ``print``()``        ``dp ``=` `dp.down;``    ` `# function which constructs the linked list``# from the given matrix of size m * n``# and returns the head pointer of the linked list``def` `constructLinkedMatrix(mat, m, n):` `    ``# stores the head of the linked list``    ``mainhead ``=` `None``;`` ` `    ``# stores the head of linked lists of each row``    ``head ``=` `[``0` `for` `i ``in` `range``(m)];``    ``righttemp ``=` `None``    ``newptr ``=` `None`` ` `    ``# Firstly, we create m linked lists``    ``# by setting all the right nodes of every row``    ``for` `i ``in` `range``(m):`` ` `        ``# initially set the head of ith row as None``        ``head[i] ``=` `None``;       ``        ``for` `j ``in` `range``(n):       ``            ``newptr ``=` `newNode(mat[i][j]);`` ` `            ``# stores the mat[0][0] node as``            ``# the mainhead of the linked list``            ``if` `(``not` `mainhead):``                ``mainhead ``=` `newptr;`` ` `            ``if` `(``not` `head[i]):``                ``head[i] ``=` `newptr;``            ``else``:``                ``righttemp.right ``=` `newptr;``            ``righttemp ``=` `newptr;``         ` `    ``# Then, for every ith and (i+1)th list,``    ``# we set the down pointers of``    ``# every node of ith list``    ``# with its corresponding``    ``# node of (i+1)th list``    ``for` `i ``in` `range``(m ``-` `1``):``        ``temp1 ``=` `head[i]``        ``temp2 ``=` `head[i ``+` `1``];`` ` `        ``while` `(temp1 ``and` `temp2):``            ``temp1.down ``=` `temp2;``            ``temp1 ``=` `temp1.right;``            ``temp2 ``=` `temp2.right;`` ` `    ``# return the mainhead pointer of the linked list``    ``return` `mainhead;`` ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:       ``    ``m ``=` `3``    ``n ``=` `3``;``    ` `    ``# 2D matrix``    ``mat``=` `[ [ ``1``, ``2``, ``3` `],``          ``[ ``4``, ``5``, ``6` `],``          ``[ ``7``, ``8``, ``9` `] ];`` ` `    ``head ``=` `constructLinkedMatrix(mat, m, n);``    ``display(head);`` ` `# This code is contributed by rutvik_56`

## C#

 `// C# implementation for above approach``using` `System;` `// Construct a Linked List from 2-D Matrix``class` `GFG``{``    ``class` `Node``    ``{``        ``public` `int` `data;``        ``public` `Node right, down;` `        ``// Default Constructor``        ``public` `Node()``        ``{``            ``this``.right = ``null``;``            ``this``.down = ``null``;``        ``}` `        ``public` `Node(``int` `d)``        ``{``            ``this``.data = d;``            ``this``.right = ``null``;``            ``this``.down = ``null``;``        ``}``    ``}` `    ``/*``    ``A function to construct a Linked List``    ``from the given matrix of size m * n``    ``and returns the head pointer of the linked list``    ``*/``    ``Node constructLinkedMatrix(``int``[,] arr,``                               ``int` `m, ``int` `n)``    ``{` `        ``// stores the head of the linked list``        ``Node mainHead = ``null``;` `        ``// stores the head of linked lists``        ``// of each row``        ``Node[] head = ``new` `Node[m];``        ``Node rightTemp = ``new` `Node(), newptr;` `        ``// Firstly, we create m linked lists``        ``// by setting all the right nodes of every row``        ``for``(``int` `i = 0; i < m; i++)``        ``{` `            ``// initially set the head of``            ``// ith row as NULL``            ``head[i] = ``null``;` `            ``for``(``int` `j = 0; j < n; j++)``            ``{``                ``newptr = ``new` `Node(arr[i, j]);` `                ``// stores the mat[0][0] node as``                ``// the mainhead of the linked list``                ``if``(mainHead == ``null``)``                    ``mainHead = newptr;``                ``if``(head[i] == ``null``)``                    ``head[i] = newptr;``                ``else``                    ``rightTemp.right = newptr;` `                ``rightTemp = newptr;``            ``}``        ``}` `        ``// Then, for every ith and (i+1)th list,``        ``// we set the down pointers of``        ``// every node of ith list``        ``// with its corresponding``        ``// node of (i+1)th list``        ``for``(``int` `i = 0; i < m - 1; i++)``        ``{``            ``Node temp1 = head[i],``                 ``temp2 = head[i + 1];` `            ``while``(temp1 != ``null` `&& temp2 != ``null``)``            ``{``                ``temp1.down = temp2;``                ``temp1 = temp1.right;``                ``temp2 = temp2.right;``            ``}``        ``}` `        ``// return the mainhead pointer``        ``// of the linked list``        ``return` `mainHead;``    ``}` `    ``// utility function to print the``    ``// linked list pointed to by head pointer``    ``void` `display(Node head)``    ``{``        ``Node rp, dp = head;` `        ``// loop until the down pointer``        ``// is not NULL``        ``while``(dp != ``null``)``        ``{``            ``rp = dp;` `            ``// loop until the right pointer``            ``// is not NULL``            ``while``(rp != ``null``)``            ``{``                ``Console.Write(rp.data + ``" "``);``                ``rp = rp.right;``            ``}``            ``Console.WriteLine();``            ``dp = dp.down;``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``GFG Obj = ``new` `GFG();``        ``int` `m = 3, n = 3; ``// m = rows and n = columns` `        ``// 2-D Matrix``        ``int``[,] arr = {{ 1, 2, 3 },``                      ``{ 4, 5, 6 },``                      ``{ 7, 8, 9 }};` `        ``Node head = Obj.constructLinkedMatrix(arr, m, n);``        ``Obj.display(head);``    ``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 `// THIS CODE IS CONTRIBUTED BY YASH AGARWAL(YASHAGARWAL2852002)``//  JavaScript program to construct a linked``//  list from 2D matrix  Iterative approach``//  node of linked list``class node{``    ``constructor(data){``        ``this``.data = data;``        ``this``.right = ``null``;``        ``this``.down = ``null``;``    ``}``}` `//  utility function to create a new node with given data``function` `newNode(d){``    ``return` `new` `node(d);``}` `//  utility function to print the linked list pointed to by head pointer``function` `display(head){``    ``let rp = head;``    ``let dp = head;``    ` `    ``//  loop until the down pointer is not null``    ``while``(dp != ``null``){``        ``rp = dp;``        ` `        ``//  loop until the right pointer is not null``        ``while``(rp != ``null``){``            ``document.write(rp.data +  ``" "``);``            ``rp = rp.right;``        ``}``        ``document.write(``"
"``);``        ``dp = dp.down;``    ``}``}` `//  function which constructs the linked list``//  from the given matrix of size m  n``//  and returns the head pointer of the linked list``function` `constructLinkedMatrix(mat, m, n){``    ``//  stores the head of the linked list``    ``let mainhead = ``null``;``    ` `    ``//  stores the head of linked lists of each row``    ``let head = [];``    ``let righttemp;``    ``let newptr;``    ` `    ``//  Firstly, we create m linked lists``    ``//  by setting all the right nodes of every row``    ``for``(let i = 0; i < m; i++){``        ``//  initially set the head of ith row as NULL``        ``head[i] = ``null``;``        ``for``(let j = 0; j

Output

```1 2 3
4 5 6
7 8 9 ```

Time complexity: O(M * N)

My Personal Notes arrow_drop_up