Print a given matrix in spiral form

Difficulty Level : Medium
Last Updated : 20 Jan, 2021

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 
Explanation: The output is matrix in spiral format. 

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
Explanation :The output is matrix in spiral format.

Method 1: This is a simple method to solve the following problem.

Approach: The problem can be solved by dividing the matrix into loops or squares or boundaries. It can be seen that the elements of the outer loop are printed first in a clockwise manner then the elements of the inner loop is printed. So printing the elements of a loop can be solved using four 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.

Algorithm:
1. Create and initialize variables k – starting row index, m – ending row index, l – starting column index, n – ending column index
2. Run a loop until all the squares of loops are printed.
3. In each outer loop traversal print the elements of a square in a clockwise manner.
4. Print the top row, i.e. Print the elements of the kth row from column index l to n, and increase the count of k.
5. Print the right column, i.e. Print the last column or n-1th column from row index k to m and decrease the count of n.
6. Print the bottom row, i.e. if k < m, then print the elements of m-1th row from column n-1 to l and decrease the count of m
7. Print the left column, i.e. if l < n, then print the elements of lth column from m-1th row to k and increase the count of l.

Below is the implementation of the above algorithm:

C++

// C++ Program to print a matrix spirally
 
#include <bits/stdc++.h>
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 Code */
int main()
{
    int a[R][C] = { { 1, 2, 3, 4, 5, 6 },
                    { 7, 8, 9, 10, 11, 12 },
                    { 13, 14, 15, 16, 17, 18 } };
     
      // Function Call
    spiralPrint(R, C, a);
    return 0;
}
 
// This is code is contributed by rathbhupendra

C

// C program to print the array in a
// spiral form
 
#include <stdio.h>
#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 Code */
int main()
{
    int a[R][C] = { { 1, 2, 3, 4, 5, 6 },
                    { 7, 8, 9, 10, 11, 12 },
                    { 13, 14, 15, 16, 17, 18 } };
     
    // Function Call
    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 Code
    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 } };
        
        // Function Call
          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
 
# Function Call
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 Code
    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 } };
         
          // Function Call
          spiralPrint(R, C, a);
    }
}
 
// This code is contributed by Sam007

PHP

<?php 
// PHP program to print a given
// matrix in spiral form
$R = 3;
$C = 6;
 
function 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 && $l < $n)
    {
        /* Print the first row from
           the remaining rows */
        for ($i = $l; $i < $n; ++$i)
        {
            echo $a[$k][$i] . " ";
        }
        $k++;
 
        /* Print the last column 
        from the remaining columns */
        for ($i = $k; $i < $m; ++$i)
        {
            echo $a[$i][$n - 1] . " ";
        }
        $n--;
 
        /* Print the last row from
           the remaining rows */
        if ($k < $m)
        {
            for ($i = $n - 1; $i >= $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));
 
// Function Call
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

Complexity Analysis:

Time Complexity: O(m*n).
To traverse the matrix O(m*n) time is required.
Space Complexity: O(1).
No extra space is required.

Method 2: (Recursive Approach)

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. The idea of printing the boundary or loops is the same.

Algorithm:
1. create a recursive function that takes a matrix and some variables (k – starting row index, m – ending row index, l – starting column index, n – ending column index) as parameters
2. Check the base cases (stating index is less than or equal to ending index) and print the boundary elements in clockwise manner
3. Print the top row, i.e. Print the elements of kth row from column index l to n, and increase the count of k.
4. Print the right column, i.e. Print the last column or n-1th column from row index k to m and decrease the count of n.
5. Print the bottom row, i.e. if k > m, then print the elements of m-1th row from column n-1 to l and decrease the count of m
6. Print the left column, i.e. if l < n, then print the elements of lth column from m-1th row to k and increase the count of l.
7. Call the function recursively with the values of starting and ending indices of rows and columns.

Below is the implementation of the above algorithm:

C++

// C++. program for the above approach
#include <iostream>
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 = j; 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 Code
int main()
{
 
    int a[R][C] = { { 1, 2, 3, 4 },
                    { 5, 6, 7, 8 },
                    { 9, 10, 11, 12 },
                    { 13, 14, 15, 16 } };
 
    // Function Call
    print(a, 0, 0, R, C);
    return 0;
}
// This Code is contributed by Ankur Goel

Java

// Java program for the above approach
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 } };
 
        // Function Call
        print(a, 0, 0, R, C);
    }
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program for the above approach
 
# 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
 
 
def printdata(arr, i, j, m, n):
 
    # If i or j lies outside the matrix
    if (i >= m or j >= n):
        return
 
    # Print First Row
    for p in range(i, n):
        print(arr[i][p], end=" ")
 
    # Print Last Column
    for p in range(i + 1, m):
        print(arr[p][n - 1], end=" ")
 
    # Print Last Row, if Last and
    # First Row are not same
    if ((m - 1) != i):
        for p in range(n - 2, j - 1, -1):
            print(arr[m - 1][p], end=" ")
 
    # Print First Column, if Last and
    # First Column are not same
    if ((n - 1) != j):
        for p in range(m - 2, i, -1):
            print(arr[p][j], end=" ")
 
    printdata(arr, i + 1, j + 1, m - 1, n - 1)
 
 
# Driver code
R = 4
C = 4
arr = [[1, 2, 3, 4],
       [5, 6, 7, 8],
       [9, 10, 11, 12],
       [13, 14, 15, 16]]
 
# Function Call
printdata(arr, 0, 0, R, C)
 
# This code is contributed by avsadityavardhan

C#

// C# program for the above approach
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 } };
        // Function Call
        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

Complexity Analysis:

Time Complexity: O(m*n).
To traverse the matrix O(m*n) time is required.
Space Complexity: O(1).
No extra space is required.

Method 3: (DFS Recursive Approach)

Approach: Another recursive approach is to consider DFS movement within the matrix (right->down->left->up->right->..->end).

We do this by modifying the matrix itself such that when DFS algorithm visits each matrix cell it’s changed to a value which cannot be contained within the matrix. The DFS algorithm is terminated when it visits a cell such that all of its surrounding cells are already visited. The direction of the DFS search is controlled by a variable.

Algorithm:

create a DFS function which takes matrix, cell indices and direction
check are cell indices pointing to a valid cell (that is, not visited and in bounds)? if not, skip this cell
print cell value
mark matrix cell pointed by indicates as visited by changing it to a value not supported in the matrix
check are surrounding cells valid? if not stop algorithm, else continue
if direction given is right then check, is the cell to the right valid? if so, DFS to the right cell given the steps above, else, change the direction to down and DFS downwards given the steps above.
else, if the direction given is down then check, is the cell to the down valid? if so, DFS to the cell below given the steps above, else, change the direction to left and DFS leftwards given the steps above.
else, if the direction given is left then check, is the cell to the left valid? if so, DFS to the left cell given the steps above, else, change the direction to up and DFS upwards given the steps above.
else, if the direction given is up then check, is the cell to the up valid? if so, DFS to the upper cell given the steps above, else, change the direction to right and DFS rightwards given the steps above.

Below is an implementation of this algorithm:

C++

#include <iostream>
#include <vector>
using namespace std;
#define R 4
#define C 4
 
bool isInBounds(int i, int j)
{
    if (i < 0 || i >= R || j < 0 || j >= C)
        return false;
    return true;
}
 
// check if the postion is blocked
bool isBlocked(int matrix[R][C], int i, int j)
{
    if (!isInBounds(i, j))
        return true;
    if (matrix[i][j] == -1)
        return true;
    return false;
}
 
 
// DFS code to traverse spirally
void spirallyDFSTravserse(int matrix[R][C], int i, int j,
                          int dir, vector<int>& res)
{
    if (isBlocked(matrix, i, j))
        return;
    bool allBlocked = true;
    for (int k = -1; k <= 1; k += 2) 
    {
        allBlocked = allBlocked
                     && isBlocked(matrix, k + i, j)
                     && isBlocked(matrix, i, j + k);
    }
    res.push_back(matrix[i][j]);
    matrix[i][j] = -1;
    if (allBlocked) 
    {
        return;
    }
     
    // dir: 0 - right, 1 - down, 2 - left, 3 - up
    int nxt_i = i;
    int nxt_j = j;
    int nxt_dir = dir;
    if (dir == 0)
    {
        if (!isBlocked(matrix, i, j + 1)) 
        {
            nxt_j++;
        }
        else
        {
            nxt_dir = 1;
            nxt_i++;
        }
    }
    else if (dir == 1) 
    {
        if (!isBlocked(matrix, i + 1, j)) 
        {
            nxt_i++;
        }
        else {
            nxt_dir = 2;
            nxt_j--;
        }
    }
    else if (dir == 2) 
    {
        if (!isBlocked(matrix, i, j - 1)) 
        {
            nxt_j--;
        }
        else
        {
            nxt_dir = 3;
            nxt_i--;
        }
    }
    else if (dir == 3) 
    {
        if (!isBlocked(matrix, i - 1, j)) 
        {
            nxt_i--;
        }
        else
        {
            nxt_dir = 0;
            nxt_j++;
        }
    }
    spirallyDFSTravserse(matrix, nxt_i, nxt_j, nxt_dir,
                         res);
}
 
// to traverse spirally
vector<int> spirallyTraverse(int matrix[R][C])
{
    vector<int> res;
    spirallyDFSTravserse(matrix, 0, 0, 0, res);
    return res;
}
 
// Driver Code
int main()
{
    int a[R][C] = { { 1, 2, 3, 4 },
                    { 5, 6, 7, 8 },
                    { 9, 10, 11, 12 },
                    { 13, 14, 15, 16 } };
 
    // Function Call
    vector<int> res = spirallyTraverse(a);
    int size = res.size();
    for (int i = 0; i < size; ++i)
        cout << res[i] << " ";
    cout << endl;
    return 0;
} //code contributed by Ephi F

Output

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

Complexity Analysis:

Time Complexity: O(m*n). To traverse the matrix O(m*n) time is required.
Space Complexity: O(1). No extra space is required (without consideration of the stack used by the recursion).

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

Related Articles

C++

C

Java

Python3

C#

PHP

C++

Java

Python3

C#

C++