# Form a Rectangle from boundary elements of Matrix using Linked List

• Difficulty Level : Hard
• Last Updated : 22 Aug, 2022

Given a Matrix grid[][] of size NxM where N is number of rows and M is number of columns. The task is to form a rectangle from boundary elements of grid[][] using linked list having four pointers namely prev, next, top and bottom. Print the final linked list.

Examples:

Input: A = [[13, 42, 93, 88],
[26, 38, 66, 42],
[75, 63, 78, 12]]
Output: 13 42 93 88 42 12 78 63 75 26

Explanation: 1. Make A and head node
2. Traverse through 0th row and create node for each element and connect them through next pointer.
3. Traverse through (m-1)th column and create node for each element and connect them through bottom pointer.
4. Traverse through (n-1)th row and create node for each element and connect them through prev pointer.
5. Traverse through 0th column and create node for each element and connect them through top pointer.
6. Step 2, 3, 4, 5 is repeated till temp. The top become equal to head.

Input: A = [[1, 2, 3]
[8, 9, 4]
[7, 6, 5]]
Output: 1 2 3 4 5 6 7 8

Approach: This problem can be solved by Performing boundary traversal of matrix and creating nodes for each element and link them using next, prev, bottom or top and create a linked list.

Follow the steps below:

Step 1: Make grid as the head of the Linked list and initialize temp as the head.
Step 2: Traverse through the first row from j=1 to j=m-1 where i=0 and create a node for each element and link them through the next pointer.
Step 3: Traverse through the last column from i=0 to i=n-1 where j=m-1 and create a node for each element and link them through a bottom pointer.
Step 4: Traverse through the last row from j=m-1 to j=0 where i=n-1 and create a node for each element and link them through the prev pointer.
Step 5: Traverse through the first column from i=n-1 to i=0 where j=0 and create a node for each element and link them through the top pointer.
Step 6: Step 2, 3, 4, 5 is repeated till temp.top becomes equal to head.
Step 7: Print the required Linked List.

Below is the implementation of the above algorithm.

## C++

 `// C++ program for above approach` `#include ` `using` `namespace` `std;`   `// Node Class` `struct` `Node {` `    ``int` `data;` `    ``Node* next;` `    ``Node* prev;` `    ``Node* top;` `    ``Node* bottom;`   `    ``// Constructor to initialize the node object` `    ``Node(``int` `data)` `    ``{` `        ``this``->data = data;` `        ``next = NULL;` `        ``prev = NULL;` `        ``top = NULL;` `        ``bottom = NULL;` `    ``}` `};`   `// Linked List class` `struct` `LinkedList {`   `    ``// initialize head` `    ``Node* head = NULL;`   `    ``// function to form square` `    ``// linked list of matrix.` `    ``void` `Quad(vector > grid, ``int` `n, ``int` `m)` `    ``{`   `        ``// initialising A as head.` `        ``head = ``new` `Node(grid);`   `        ``// head is assigned to head.` `        ``Node* temp = head;`   `        ``// i is row index, j is column index` `        ``int` `i = 0;` `        ``int` `j = 1;`   `        ``// loop till temp.top become equal to head.` `        ``while` `(temp != NULL and temp->top != head) {` `            ``// as we iterating over boundary` `            ``// of matrix so we will iterate` `            ``// over first(0) and last(n-1) row` `            ``// and first(0) and last(m-1) column.`   `            ``// iterating over first i.e 0th row` `            ``// and connecting node.` `            ``if` `(j < m && i == 0) {` `                ``temp->next = ``new` `Node(grid[i][j]);` `                ``temp = temp->next;` `                ``j += 1;` `            ``}`   `            ``// iterating over last i.e (m-1)th` `            ``// column and connecting Node.` `            ``else` `if` `(j == m && i < n - 1) {` `                ``i = i + 1;` `                ``temp->bottom = ``new` `Node(grid[i][j - 1]);` `                ``temp = temp->bottom;` `            ``}`   `            ``// iterating over last i.e (n-1)th row` `            ``// and connecting Node.` `            ``else` `if` `(i == n - 1 && j <= m && j >= 1) {` `                ``if` `(j == m)` `                    ``j = j - 1;` `                ``j = j - 1;` `                ``temp->prev = ``new` `Node(grid[i][j]);` `                ``temp = temp->prev;` `            ``}`   `            ``// iterating over first i.e 0th column` `            ``// and connecting Node.` `            ``else` `if` `(i <= n - 1 && j == 0) {` `                ``i = i - 1;` `                ``temp->top = ``new` `Node(grid[i][j]);` `                ``temp = temp->top;` `                ``if` `(i == 1)` `                    ``temp->top = head;` `            ``}` `        ``}` `    ``}`   `    ``// function to print Linked list.` `    ``void` `printList(Node* root)` `    ``{`   `        ``Node* temp = root;`   `        ``// printing head of linked list` `        ``cout << temp->data << ``" "``;`   `        ``// loop till temp.top` `        ``// become equal to head` `        ``while` `(temp->top != root) {`   `            ``// printing the node` `            ``if` `(temp->next) {` `                ``cout << temp->next->data << ``" "``;` `                ``temp = temp->next;` `            ``}` `            ``if` `(temp->prev) {` `                ``cout << temp->prev->data << ``" "``;` `                ``temp = temp->prev;` `            ``}` `            ``if` `(temp->bottom) {` `                ``cout << temp->bottom->data << ``" "``;` `                ``temp = temp->bottom;` `            ``}` `            ``if` `(temp->top) {` `                ``cout << temp->top->data << ``" "``;` `                ``temp = temp->top;` `            ``}` `        ``}` `    ``}` `};`   `// Driver Code` `int` `main()` `{` `    ``vector > grid = { { 13, 42, 93, 88 },` `                                  ``{ 26, 38, 66, 42 },` `                                  ``{ 75, 63, 78, 12 } };`   `    ``// n is number of rows` `    ``int` `n = grid.size();` `    `  `    ``// m is number of columns` `    ``int` `m = grid.size();` `  `  `    ``// creation of object` `    ``LinkedList* l = ``new` `LinkedList();`   `    ``// Call Quad method to create Linked List.` `    ``l->Quad(grid, n, m);`   `    ``// Call Quad method to create Linked List.` `    ``l->printList(l->head);`   `    ``return` `0;` `}`   `// The code is contributed by Gautam goel (gautamgoel962)`

## Java

 `// Java program for above approach`   `// Node Class` `class` `Node {` `    ``int` `data;` `    ``Node next;` `    ``Node prev;` `    ``Node top;` `    ``Node bottom;` `    ``// Constructor to initialize the node object` `    ``Node(``int` `data)` `    ``{` `        ``this``.data = data;` `        ``next = ``null``;` `        ``prev = ``null``;` `        ``top = ``null``;` `        ``bottom = ``null``;` `    ``}` `}`   `class` `GFG {`   `    ``// initialize head` `    ``public` `Node head = ``null``;`   `    ``// function to form square linked list of matrix.` `    ``public` `void` `Quad(``int``[][] grid, ``int` `n, ``int` `m)` `    ``{`   `        ``// initialising A as head.` `        ``head = ``new` `Node(grid[``0``][``0``]);`   `        ``// head is assigned to head.` `        ``Node temp = head;`   `        ``// i is row index, j is column index` `        ``int` `i = ``0``;` `        ``int` `j = ``1``;`   `        ``// loop till temp.top become equal to head.` `        ``while` `(temp.top != head) {` `            ``// as we iterating over boundary` `            ``// of matrix so we will iterate` `            ``// over first(0) and last(n-1) row` `            ``// and first(0) and last(m-1) column.`   `            ``// iterating over first i.e 0th row` `            ``// and connecting node.` `            ``if` `(j < m && i == ``0``) {` `                ``temp.next = ``new` `Node(grid[i][j]);` `                ``temp = temp.next;` `                ``j += ``1``;` `            ``}`   `            ``// iterating over last i.e (m-1)th` `            ``// column and connecting Node.` `            ``else` `if` `(j == m && i < n - ``1``) {` `                ``i = i + ``1``;` `                ``temp.bottom = ``new` `Node(grid[i][j - ``1``]);` `                ``temp = temp.bottom;` `            ``}`   `            ``// iterating over last i.e (n-1)th row` `            ``// and connecting Node.` `            ``else` `if` `(i == n - ``1` `&& j <= m && j >= ``1``) {` `                ``if` `(j == m) {` `                    ``j = j - ``1``;` `                ``}` `                ``j = j - ``1``;` `                ``temp.prev = ``new` `Node(grid[i][j]);` `                ``temp = temp.prev;` `            ``}`   `            ``// iterating over first i.e 0th column` `            ``// and connecting Node.` `            ``else` `if` `(i <= n - ``1` `&& j == ``0``) {` `                ``i = i - ``1``;` `                ``temp.top = ``new` `Node(grid[i][j]);` `                ``temp = temp.top;` `                ``if` `(i == ``1``) {` `                    ``temp.top = head;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// function to print Linked list.` `    ``public` `void` `printList(Node root)` `    ``{` `        ``Node temp = root;`   `        ``// printing head of linked list` `        ``System.out.print(temp.data + ``" "``);`   `        ``// loop till temp.top` `        ``// become equal to head` `        ``while` `(temp.top != root) {`   `            ``// printing the node` `            ``if` `(temp.next != ``null``) {` `                ``System.out.print(temp.next.data + ``" "``);` `                ``temp = temp.next;` `            ``}` `            ``if` `(temp.prev != ``null``) {` `                ``System.out.print(temp.prev.data + ``" "``);` `                ``temp = temp.prev;` `            ``}` `            ``if` `(temp.bottom != ``null``) {` `                ``System.out.print(temp.bottom.data + ``" "``);` `                ``temp = temp.bottom;` `            ``}` `            ``if` `(temp.top != ``null``) {` `                ``System.out.print(temp.top.data + ``" "``);` `                ``temp = temp.top;` `            ``}` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``int``[][] grid = ``new` `int``[][] { { ``13``, ``42``, ``93``, ``88` `},` `                                     ``{ ``26``, ``38``, ``66``, ``42` `},` `                                     ``{ ``75``, ``63``, ``78``, ``12` `} };`   `        ``// n is number of rows` `        ``int` `n = grid.length;`   `        ``// m is number of columns` `        ``int` `m = grid[``0``].length;`   `        ``GFG l = ``new` `GFG();`   `        ``// Call Quad method to create Linked List.` `        ``l.Quad(grid, n, m);`   `        ``// Call Quad method to create Linked List.` `        ``l.printList(l.head);` `    ``}` `}`   `// This code is contributed by lokesh (lokeshmvs21).`

## Python3

 `# Python program for above approach` `# Node Class` `class` `Node:`   `    ``# Constructor to initialize the node object` `    ``def` `__init__(``self``, val):` `        ``self``.data ``=` `val` `        ``self``.``next` `=` `None` `        ``self``.prev ``=` `None` `        ``self``.top ``=` `None` `        ``self``.bottom ``=` `None`     `# Linked List class` `class` `LinkedList:`   `    ``# Constructor to initialize head` `    ``def` `__init__(``self``):` `        ``self``.head ``=` `None`   `    ``# function to form square` `    ``# linked list of matrix.` `    ``def` `Quad(``self``, grid, n, m):`   `        ``# initialising A as head.` `        ``self``.head ``=` `Node(grid[``0``][``0``])`   `        ``# head is assigned to head.` `        ``temp ``=` `self``.head`   `        ``# i is row index, j is column index` `        ``i ``=` `0` `        ``j ``=` `1`   `        ``# loop till temp.top become equal to head.` `        ``while` `temp.top !``=` `self``.head:` `            ``# as we iterating over boundary` `            ``# of matrix so we will iterate` `            ``# over first(0) and last(n-1) row ` `            ``# and first(0) and last(m-1) column.`   `            ``# iterating over first i.e 0th row ` `            ``# and connecting node.` `            ``if` `j < m ``and` `i ``=``=` `0``:` `                ``temp.``next` `=` `Node(grid[i][j])` `                ``temp ``=` `temp.``next` `                ``j ``+``=` `1`   `            ``# iterating over last i.e (m-1)th` `            ``# column and connecting Node.` `            ``elif` `j ``=``=` `m ``and` `i < n ``-` `1``:` `                ``i ``=` `i ``+` `1` `                ``temp.bottom ``=` `Node(grid[i][j ``-` `1``])` `                ``temp ``=` `temp.bottom`   `            ``# iterating over last i.e (n-1)th row` `            ``# and connecting Node.` `            ``elif` `i ``=``=` `n ``-` `1` `and` `j <``=` `m ``and` `j >``=` `1``:` `                ``if` `j ``=``=` `m: j ``=` `j ``-` `1` `                ``j ``=` `j ``-` `1` `                ``temp.prev ``=` `Node(grid[i][j])` `                ``temp ``=` `temp.prev`   `            ``# iterating over first i.e 0th column` `            ``# and connecting Node.` `            ``elif` `i <``=` `n ``-` `1` `and` `j ``=``=` `0``:` `                ``i ``=` `i ``-` `1` `                ``temp.top ``=` `Node(grid[i][j])` `                ``temp ``=` `temp.top` `                ``if` `i ``=``=` `1``:` `                    ``temp.top ``=` `self``.head`   `    ``# function to print Linked list.` `    ``def` `printList(``self``, root):` `        `  `        ``temp ``=` `root` `        `  `        ``# printing head of linked list` `        ``print``(temp.data, end ``=``" "``)` `        `  `        ``# loop till temp.top` `        ``# become equal to head` `        ``while` `temp.top !``=` `root:` `          `  `          ``# printing the node` `            ``if` `temp.``next``:` `                ``print``(temp.``next``.data, end ``=``" "``)` `                ``temp ``=` `temp.``next` `            ``if` `temp.prev:` `                ``print``(temp.prev.data, end ``=``" "``)` `                ``temp ``=` `temp.prev` `            ``if` `temp.bottom:` `                ``print``(temp.bottom.data, end ``=``" "``)` `                ``temp ``=` `temp.bottom` `            ``if` `temp.top:` `                ``print``(temp.top.data, end ``=``" "``)` `                ``temp ``=` `temp.top`   `# Driver Code` `grid ``=` `[[``13``, ``42``, ``93``, ``88``],    ` `        ``[``26``, ``38``, ``66``, ``42``],` `        ``[``75``, ``63``, ``78``, ``12``]]`   `# n is number of rows` `n ``=` `len``(grid)`   `# m is number of column` `m ``=` `len``(grid[``0``])`   `# creation of object` `l ``=` `LinkedList()`   `# Call Quad method to create Linked List.` `l.Quad(grid, n, m)`   `# Call printList method to print list.` `l.printList(l.head)`

## C#

 `// C# program for above approach` `using` `System;`   `// Node Class` `class` `Node {` `  ``public` `int` `data;` `  ``public` `Node next;` `  ``public` `Node prev;` `  ``public` `Node top;` `  ``public` `Node bottom;`   `  ``// Constructor to initialize the node object` `  ``public` `Node(``int` `data)` `  ``{` `    ``this``.data = data;` `    ``this``.next = ``null``;` `    ``this``.prev = ``null``;` `    ``this``.top = ``null``;` `    ``this``.bottom = ``null``;` `  ``}` `}`   `public` `class` `GFG {`   `  ``// initialize head` `  ``Node head = ``null``;`   `  ``// function to form square linked list of matrix.` `  ``public` `void` `Quad(``int``[, ] grid, ``int` `n, ``int` `m)` `  ``{`   `    ``// initialising A as head.` `    ``head = ``new` `Node(grid[0, 0]);`   `    ``// head is assigned to head.` `    ``Node temp = head;`   `    ``// i is row index, j is column index` `    ``int` `i = 0;` `    ``int` `j = 1;`   `    ``// loop till temp.top become equal to head.` `    ``while` `(temp.top != head) ` `    ``{` `      `  `      ``// as we iterating over boundary` `      ``// of matrix so we will iterate` `      ``// over first(0) and last(n-1) row` `      ``// and first(0) and last(m-1) column.`   `      ``// iterating over first i.e 0th row` `      ``// and connecting node.` `      ``if` `(j < m && i == 0) {` `        ``temp.next = ``new` `Node(grid[i, j]);` `        ``temp = temp.next;` `        ``j += 1;` `      ``}`   `      ``// iterating over last i.e (m-1)th` `      ``// column and connecting Node.` `      ``else` `if` `(j == m && i < n - 1) {` `        ``i = i + 1;` `        ``temp.bottom = ``new` `Node(grid[i, j - 1]);` `        ``temp = temp.bottom;` `      ``}`   `      ``// iterating over last i.e (n-1)th row` `      ``// and connecting Node.` `      ``else` `if` `(i == n - 1 && j <= m && j >= 1) {` `        ``if` `(j == m) {` `          ``j = j - 1;` `        ``}` `        ``j = j - 1;` `        ``temp.prev = ``new` `Node(grid[i, j]);` `        ``temp = temp.prev;` `      ``}`   `      ``// iterating over first i.e 0th column` `      ``// and connecting Node.` `      ``else` `if` `(i <= n - 1 && j == 0) {` `        ``i = i - 1;` `        ``temp.top = ``new` `Node(grid[i, j]);` `        ``temp = temp.top;` `        ``if` `(i == 1) {` `          ``temp.top = head;` `        ``}` `      ``}` `    ``}` `  ``}`   `  ``// function to print Linked list.` `  ``void` `printList(Node root)` `  ``{` `    ``Node temp = root;`   `    ``// printing head of linked list` `    ``Console.Write(temp.data + ``" "``);`   `    ``// loop till temp.top` `    ``// become equal to head` `    ``while` `(temp.top != root) {`   `      ``// printing the node` `      ``if` `(temp.next != ``null``) {` `        ``Console.Write(temp.next.data + ``" "``);` `        ``temp = temp.next;` `      ``}` `      ``if` `(temp.prev != ``null``) {` `        ``Console.Write(temp.prev.data + ``" "``);` `        ``temp = temp.prev;` `      ``}` `      ``if` `(temp.bottom != ``null``) {` `        ``Console.Write(temp.bottom.data + ``" "``);` `        ``temp = temp.bottom;` `      ``}` `      ``if` `(temp.top != ``null``) {` `        ``Console.Write(temp.top.data + ``" "``);` `        ``temp = temp.top;` `      ``}` `    ``}` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Code` `    ``int``[, ] grid = { { 13, 42, 93, 88 },` `                    ``{ 26, 38, 66, 42 },` `                    ``{ 75, 63, 78, 12 } };`   `    ``// n is number of rows` `    ``int` `n = grid.GetLength(0);`   `    ``// m is number of columns` `    ``int` `m = grid.GetLength(1);`   `    ``GFG l = ``new` `GFG();`   `    ``// Call Quad method to create Linked List.` `    ``l.Quad(grid, n, m);`   `    ``// Call Quad method to create Linked List.` `    ``l.printList(l.head);` `  ``}` `}`   `// This code is contributed by lokesh (lokeshmvs21).`

## Javascript

 ``

Output

`13 42 93 88 42 12 78 63 75 26 `

Time Complexity: O(N*M)
Auxiliary Space: O(N*M)

My Personal Notes arrow_drop_up
Recommended Articles
Page :