# Print a given matrix in spiral form

Given a 2D array, print it in spiral form. See the following examples.

Examples:

```Input:
1    2   3   4
5    6   7   8
9   10  11  12
13  14  15  16
Output:
1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10

Input:
1   2   3   4  5   6
7   8   9  10  11  12
13  14  15 16  17  18
Output:
1 2 3 4 5 6 12 18 17 16 15 14 13 7 8 9 10 11
``` ## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Approach: The above problem can be solved using four for loops which prints all the elements. Every for loop defines a single direction movement along with the matrix. The first for loop represents the movement from left to right, whereas the second crawl represents the movement from top to bottom, the third represents the movement from the right to left, and the fourth represents the movement from bottom to up. The four variable along with their use is given below.

```k - starting row index
m - ending row index
l - starting column index
n - ending column index
```

Below is the implementation of the above approach:

## C++

 `#include ` `using` `namespace` `std; ` `#define R 3 ` `#define C 6 ` ` `  `void` `spiralPrint(``int` `m, ``int` `n, ``int` `a[R][C]) ` `{ ` `    ``int` `i, k = 0, l = 0; ` ` `  `    ``/* k - starting row index  ` `        ``m - ending row index  ` `        ``l - starting column index  ` `        ``n - ending column index  ` `        ``i - iterator  ` `    ``*/` ` `  `    ``while` `(k < m && l < n) { ` `        ``/* Print the first row from ` `               ``the remaining rows */` `        ``for` `(i = l; i < n; ++i) { ` `            ``cout << a[k][i] << ``" "``; ` `        ``} ` `        ``k++; ` ` `  `        ``/* Print the last column  ` `         ``from the remaining columns */` `        ``for` `(i = k; i < m; ++i) { ` `            ``cout << a[i][n - 1] << ``" "``; ` `        ``} ` `        ``n--; ` ` `  `        ``/* Print the last row from  ` `                ``the remaining rows */` `        ``if` `(k < m) { ` `            ``for` `(i = n - 1; i >= l; --i) { ` `                ``cout << a[m - 1][i] << ``" "``; ` `            ``} ` `            ``m--; ` `        ``} ` ` `  `        ``/* Print the first column from ` `                   ``the remaining columns */` `        ``if` `(l < n) { ` `            ``for` `(i = m - 1; i >= k; --i) { ` `                ``cout << a[i][l] << ``" "``; ` `            ``} ` `            ``l++; ` `        ``} ` `    ``} ` `} ` ` `  `/* Driver program to test above functions */` `int` `main() ` `{ ` `    ``int` `a[R][C] = { { 1, 2, 3, 4, 5, 6 }, ` `                    ``{ 7, 8, 9, 10, 11, 12 }, ` `                    ``{ 13, 14, 15, 16, 17, 18 } }; ` ` `  `    ``spiralPrint(R, C, a); ` `    ``return` `0; ` `} ` ` `  `// This is code is contributed by rathbhupendra `

## C

 `/* This code is adopted from the solution given  ` `   ``@ http:// effprog.blogspot.com/2011/01/spiral-printing-of-two-dimensional.html */` ` `  `#include ` `#define R 3 ` `#define C 6 ` ` `  `void` `spiralPrint(``int` `m, ``int` `n, ``int` `a[R][C]) ` `{ ` `    ``int` `i, k = 0, l = 0; ` ` `  `    ``/*  k - starting row index ` `        ``m - ending row index ` `        ``l - starting column index ` `        ``n - ending column index ` `        ``i - iterator ` `    ``*/` ` `  `    ``while` `(k < m && l < n) { ` `        ``/* Print the first row from the remaining rows */` `        ``for` `(i = l; i < n; ++i) { ` `            ``printf``(``"%d "``, a[k][i]); ` `        ``} ` `        ``k++; ` ` `  `        ``/* Print the last column from the remaining columns */` `        ``for` `(i = k; i < m; ++i) { ` `            ``printf``(``"%d "``, a[i][n - 1]); ` `        ``} ` `        ``n--; ` ` `  `        ``/* Print the last row from the remaining rows */` `        ``if` `(k < m) { ` `            ``for` `(i = n - 1; i >= l; --i) { ` `                ``printf``(``"%d "``, a[m - 1][i]); ` `            ``} ` `            ``m--; ` `        ``} ` ` `  `        ``/* Print the first column from the remaining columns */` `        ``if` `(l < n) { ` `            ``for` `(i = m - 1; i >= k; --i) { ` `                ``printf``(``"%d "``, a[i][l]); ` `            ``} ` `            ``l++; ` `        ``} ` `    ``} ` `} ` ` `  `/* Driver program to test above functions */` `int` `main() ` `{ ` `    ``int` `a[R][C] = { { 1, 2, 3, 4, 5, 6 }, ` `                    ``{ 7, 8, 9, 10, 11, 12 }, ` `                    ``{ 13, 14, 15, 16, 17, 18 } }; ` ` `  `    ``spiralPrint(R, C, a); ` `    ``return` `0; ` `} `

## Java

 `// Java program to print a given matrix in spiral form ` `import` `java.io.*; ` ` `  `class` `GFG { ` `    ``// Function print matrix in spiral form ` `    ``static` `void` `spiralPrint(``int` `m, ``int` `n, ``int` `a[][]) ` `    ``{ ` `        ``int` `i, k = ``0``, l = ``0``; ` `        ``/*  k - starting row index ` `        ``m - ending row index ` `        ``l - starting column index ` `        ``n - ending column index ` `        ``i - iterator ` `        ``*/` ` `  `        ``while` `(k < m && l < n) { ` `            ``// Print the first row from the remaining rows ` `            ``for` `(i = l; i < n; ++i) { ` `                ``System.out.print(a[k][i] + ``" "``); ` `            ``} ` `            ``k++; ` ` `  `            ``// Print the last column from the remaining columns ` `            ``for` `(i = k; i < m; ++i) { ` `                ``System.out.print(a[i][n - ``1``] + ``" "``); ` `            ``} ` `            ``n--; ` ` `  `            ``// Print the last row from the remaining rows */ ` `            ``if` `(k < m) { ` `                ``for` `(i = n - ``1``; i >= l; --i) { ` `                    ``System.out.print(a[m - ``1``][i] + ``" "``); ` `                ``} ` `                ``m--; ` `            ``} ` ` `  `            ``// Print the first column from the remaining columns */ ` `            ``if` `(l < n) { ` `                ``for` `(i = m - ``1``; i >= k; --i) { ` `                    ``System.out.print(a[i][l] + ``" "``); ` `                ``} ` `                ``l++; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// driver program ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `R = ``3``; ` `        ``int` `C = ``6``; ` `        ``int` `a[][] = { { ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `}, ` `                      ``{ ``7``, ``8``, ``9``, ``10``, ``11``, ``12` `}, ` `                      ``{ ``13``, ``14``, ``15``, ``16``, ``17``, ``18` `} }; ` `        ``spiralPrint(R, C, a); ` `    ``} ` `} ` ` `  `// Contributed by Pramod Kumar `

## Python3

 `# Python3 program to print  ` `# given matrix in spiral form ` `def` `spiralPrint(m, n, a) : ` `    ``k ``=` `0``; l ``=` `0` ` `  `    ``''' k - starting row index ` `        ``m - ending row index ` `        ``l - starting column index ` `        ``n - ending column index ` `        ``i - iterator '''` `     `  ` `  `    ``while` `(k < m ``and` `l < n) : ` `         `  `        ``# Print the first row from ` `        ``# the remaining rows  ` `        ``for` `i ``in` `range``(l, n) : ` `            ``print``(a[k][i], end ``=` `" "``) ` `             `  `        ``k ``+``=` `1` ` `  `        ``# Print the last column from ` `        ``# the remaining columns  ` `        ``for` `i ``in` `range``(k, m) : ` `            ``print``(a[i][n ``-` `1``], end ``=` `" "``) ` `             `  `        ``n ``-``=` `1` ` `  `        ``# Print the last row from ` `        ``# the remaining rows  ` `        ``if` `( k < m) : ` `             `  `            ``for` `i ``in` `range``(n ``-` `1``, (l ``-` `1``), ``-``1``) : ` `                ``print``(a[m ``-` `1``][i], end ``=` `" "``) ` `             `  `            ``m ``-``=` `1` `         `  `        ``# Print the first column from ` `        ``# the remaining columns  ` `        ``if` `(l < n) : ` `            ``for` `i ``in` `range``(m ``-` `1``, k ``-` `1``, ``-``1``) : ` `                ``print``(a[i][l], end ``=` `" "``) ` `             `  `            ``l ``+``=` `1` ` `  `# Driver Code ` `a ``=` `[ [``1``, ``2``, ``3``, ``4``, ``5``, ``6``], ` `      ``[``7``, ``8``, ``9``, ``10``, ``11``, ``12``], ` `      ``[``13``, ``14``, ``15``, ``16``, ``17``, ``18``] ] ` `       `  `R ``=` `3``; C ``=` `6` `spiralPrint(R, C, a) ` ` `  `# This code is contributed by Nikita Tiwari. `

## C#

 `// C# program to print a given ` `// matrix in spiral form ` `using` `System; ` ` `  `class` `GFG { ` `    ``// Function print matrix in spiral form ` `    ``static` `void` `spiralPrint(``int` `m, ``int` `n, ``int``[, ] a) ` `    ``{ ` `        ``int` `i, k = 0, l = 0; ` `        ``/* k - starting row index ` `        ``m - ending row index ` `        ``l - starting column index ` `        ``n - ending column index ` `        ``i - iterator ` `        ``*/` ` `  `        ``while` `(k < m && l < n) { ` `            ``// Print the first row  ` `            ``// from the remaining rows ` `            ``for` `(i = l; i < n; ++i) { ` `                ``Console.Write(a[k, i] + ``" "``); ` `            ``} ` `            ``k++; ` ` `  `            ``// Print the last column from the ` `            ``// remaining columns ` `            ``for` `(i = k; i < m; ++i) { ` `                ``Console.Write(a[i, n - 1] + ``" "``); ` `            ``} ` `            ``n--; ` ` `  `            ``// Print the last row from  ` `            ``// the remaining rows  ` `            ``if` `(k < m) { ` `                ``for` `(i = n - 1; i >= l; --i) { ` `                    ``Console.Write(a[m - 1, i] + ``" "``); ` `                ``} ` `                ``m--; ` `            ``} ` ` `  `            ``// Print the first column from  ` `            ``// the remaining columns ` `            ``if` `(l < n) { ` `                ``for` `(i = m - 1; i >= k; --i) { ` `                    ``Console.Write(a[i, l] + ``" "``); ` `                ``} ` `                ``l++; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Driver program ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `R = 3; ` `        ``int` `C = 6; ` `        ``int``[, ] a = { { 1, 2, 3, 4, 5, 6 }, ` `                      ``{ 7, 8, 9, 10, 11, 12 }, ` `                      ``{ 13, 14, 15, 16, 17, 18 } }; ` `        ``spiralPrint(R, C, a); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007 `

## PHP

 `= ``\$l``; --``\$i``) ` `            ``{ ` `                ``echo` `\$a``[``\$m` `- 1][``\$i``] . ``" "``; ` `            ``} ` `            ``\$m``--; ` `        ``} ` ` `  `        ``/* Print the first column from ` `           ``the remaining columns */` `        ``if` `(``\$l` `< ``\$n``) ` `        ``{ ` `            ``for` `(``\$i` `= ``\$m` `- 1; ``\$i` `>= ``\$k``; --``\$i``) ` `            ``{ ` `                ``echo` `\$a``[``\$i``][``\$l``] . ``" "``; ` `            ``} ` `            ``\$l``++;  ` `        ``}      ` `    ``} ` `} ` ` `  `// Driver code ` `\$a` `= ``array``(``array``(1, 2, 3, 4, 5, 6), ` `           ``array``(7, 8, 9, 10, 11, 12), ` `           ``array``(13, 14, 15, 16, 17, 18)); ` ` `  `spiralPrint(``\$R``, ``\$C``, ``\$a``); ` ` `  `// This code is contributed ` `// by ChitraNayal ` `?> `

Output:

```1 2 3 4 5 6 12 18 17 16 15 14 13 7 8 9 10 11
```

Time Complexity: Time complexity of the above solution is O(mn).

Recursive Approach:

The above problem can be solved by printing the boundary of the Matrix recursively. In each recursive call, we decrease the dimensions of the matrix.

Below is the Recursive implementation for the same:

## C++

 `#include ` `using` `namespace` `std; ` ` `  `#define R 4 ` `#define C 4 ` ` `  `// Function for printing matrix in spiral ` `// form i, j: Start index of matrix, row  ` `// and column respectively m, n: End index ` `// of matrix row and column respectively ` `void` `print(``int` `arr[R][C], ``int` `i,  ` `                     ``int` `j, ``int` `m, ``int` `n) ` `{ ` `    ``// If i or j lies outside the matrix ` `    ``if` `(i >= m or j >= n) ` `        ``return``; ` ` `  `    ``// Print First Row ` `    ``for` `(``int` `p = i; p < n; p++) ` `        ``cout << arr[i][p] << ``" "``; ` ` `  `    ``// Print Last Column ` `    ``for` `(``int` `p = i + 1; p < m; p++) ` `        ``cout << arr[p][n - 1] << ``" "``; ` ` `  `    ``// Print Last Row, if Last and ` `    ``// First Row are not same ` `    ``if` `((m - 1) != i) ` `        ``for` `(``int` `p = n - 2; p >= j; p--) ` `            ``cout << arr[m - 1][p] << ``" "``; ` ` `  `    ``// Print First Column,  if Last and ` `    ``// First Column are not same ` `    ``if` `((n - 1) != j) ` `        ``for` `(``int` `p = m - 2; p > i; p--) ` `            ``cout << arr[p][j] << ``" "``; ` ` `  `    ``print(arr, i + 1, j + 1, m - 1, n - 1); ` `} ` ` `  `// Driver Program ` `int` `main() ` `{ ` ` `  `    ``int` `a[R][C] = { { 1, 2, 3, 4 }, ` `                    ``{ 5, 6, 7, 8 }, ` `                    ``{ 9, 10, 11, 12 }, ` `                    ``{ 13, 14, 15, 16 } }; ` ` `  `    ``print(a, 0, 0, R, C); ` `    ``return` `0; ` `} ` `// This Code is contributed by Ankur Goel `

## Java

 `// Java Program to test 1/e law  ` `// for Secretary Problem : ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `    ``static` `int` `R = ``4``; ` `    ``static` `int` `C = ``4``; ` ` `  `    ``// Function for printing matrix in spiral ` `    ``// form i, j: Start index of matrix, row  ` `    ``// and column respectively m, n: End index ` `    ``// of matrix row and column respectively ` `    ``static` `void` `print(``int` `arr[][], ``int` `i, ` `                      ``int` `j, ``int` `m, ``int` `n) ` `    ``{ ` `        ``// If i or j lies outside the matrix ` `        ``if` `(i >= m || j >= n) ` `        ``{ ` `            ``return``; ` `        ``} ` ` `  `        ``// Print First Row ` `        ``for` `(``int` `p = i; p < n; p++) ` `        ``{ ` `            ``System.out.print(arr[i][p] + ``" "``); ` `        ``} ` ` `  `        ``// Print Last Column ` `        ``for` `(``int` `p = i + ``1``; p < m; p++)  ` `        ``{ ` `            ``System.out.print(arr[p][n - ``1``] + ``" "``); ` `        ``} ` ` `  `        ``// Print Last Row, if Last and ` `        ``// First Row are not same ` `        ``if` `((m - ``1``) != i)  ` `        ``{ ` `            ``for` `(``int` `p = n - ``2``; p >= j; p--)  ` `            ``{ ` `                ``System.out.print(arr[m - ``1``][p] + ``" "``); ` `            ``} ` `        ``} ` ` `  `        ``// Print First Column, if Last and ` `        ``// First Column are not same ` `        ``if` `((n - ``1``) != j)  ` `        ``{ ` `            ``for` `(``int` `p = m - ``2``; p > i; p--)  ` `            ``{ ` `                ``System.out.print(arr[p][j] + ``" "``); ` `            ``} ` `        ``} ` `        ``print(arr, i + ``1``, j + ``1``, m - ``1``, n - ``1``); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `a[][] = {{``1``, ``2``, ``3``, ``4``}, ` `                     ``{``5``, ``6``, ``7``, ``8``}, ` `                     ``{``9``, ``10``, ``11``, ``12``}, ` `                     ``{``13``, ``14``, ``15``, ``16``}}; ` ` `  `        ``print(a, ``0``, ``0``, R, C); ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## C#

 `// C# Program to test 1/e law  ` `// for Secretary Problem : ` `using` `System; ` `     `  `class` `GFG ` `{ ` `    ``static` `int` `R = 4; ` `    ``static` `int` `C = 4; ` ` `  `    ``// Function for printing matrix in spiral ` `    ``// form i, j: Start index of matrix, row  ` `    ``// and column respectively m, n: End index ` `    ``// of matrix row and column respectively ` `    ``static` `void` `print(``int` `[,]arr, ``int` `i, ` `                      ``int` `j, ``int` `m, ``int` `n) ` `    ``{ ` `        ``// If i or j lies outside the matrix ` `        ``if` `(i >= m || j >= n) ` `        ``{ ` `            ``return``; ` `        ``} ` ` `  `        ``// Print First Row ` `        ``for` `(``int` `p = i; p < n; p++) ` `        ``{ ` `            ``Console.Write(arr[i, p] + ``" "``); ` `        ``} ` ` `  `        ``// Print Last Column ` `        ``for` `(``int` `p = i + 1; p < m; p++)  ` `        ``{ ` `            ``Console.Write(arr[p, n - 1] + ``" "``); ` `        ``} ` ` `  `        ``// Print Last Row, if Last and ` `        ``// First Row are not same ` `        ``if` `((m - 1) != i)  ` `        ``{ ` `            ``for` `(``int` `p = n - 2; p >= j; p--)  ` `            ``{ ` `                ``Console.Write(arr[m - 1, p] + ``" "``); ` `            ``} ` `        ``} ` ` `  `        ``// Print First Column, if Last and ` `        ``// First Column are not same ` `        ``if` `((n - 1) != j)  ` `        ``{ ` `            ``for` `(``int` `p = m - 2; p > i; p--)  ` `            ``{ ` `                ``Console.Write(arr[p, j] + ``" "``); ` `            ``} ` `        ``} ` `        ``print(arr, i + 1, j + 1, m - 1, n - 1); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``int` `[,]a = {{1, 2, 3, 4}, ` `                    ``{5, 6, 7, 8}, ` `                    ``{9, 10, 11, 12}, ` `                    ``{13, 14, 15, 16}}; ` ` `  `        ``print(a, 0, 0, R, C); ` `    ``} ` `}  ` ` `  `// This code is contributed by Princi Singh `

Output:

```1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10
```

Please write comments if you find the above code incorrect, or find other ways to solve the same problem.

My Personal Notes arrow_drop_up

Article Tags :

58

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.