Print a Matrix in Spiral Order Optimal Algorithm with Example

Matrix

Contents

VisualizationProblemExamplesSolutionAlgorithmCode

Visualization Player

Problem Statement❯

Given a 2D matrix, your task is to print all its elements in a spiral order starting from the top-left corner and moving clockwise layer by layer.

In spiral order, you start by printing the top row, then the rightmost column, then the bottom row in reverse, and finally the leftmost column from bottom to top. This process is repeated for the inner layers until all elements are printed.

If the matrix is empty or has no elements, the output should be an empty list.

Examples❯

Input Matrix Spiral Output Description
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[1, 2, 3, 6, 9, 8, 7, 4, 5]
3x3 square matrix, classic spiral flow
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
[1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7]
3x4 rectangular matrix (more columns)
[[1], [2], [3], [4]]
[1, 2, 3, 4]
Single column matrix (4x1)
[[1, 2, 3, 4]]
[1, 2, 3, 4]
Single row matrix (1x4)
[[5]] [5] Single element matrix
[] [] Empty matrix, no elements to print

Solution❯

Understanding the Problem

We are given a 2D matrix and asked to print its elements in a spiral order. That means starting from the top-left corner, we go right along the top row, then down the rightmost column, then left along the bottom row, then up the leftmost column—repeating this process inward like peeling layers of an onion until all elements are visited.

For a beginner, think of walking around the boundary of the matrix, one layer at a time, and collecting the numbers in the order you walk.

Step-by-Step Solution with Example

step 1: Initialize boundaries

We define four variables to represent the current unvisited part of the matrix:

  • top – the index of the first row not yet printed
  • bottom – the index of the last row not yet printed
  • left – the index of the first column not yet printed
  • right – the index of the last column not yet printed

step 2: Traverse in spiral order

We use a loop and at each iteration, follow this order:

  1. Go left to right across the top row
  2. Go top to bottom along the rightmost column
  3. If rows remain, go right to left along the bottom row
  4. If columns remain, go bottom to top along the leftmost column

After completing a side, update the boundary variables to move inward (e.g., top++, right--, etc.).

step 3: Continue until all elements are visited

The loop continues as long as top ≤ bottom and left ≤ right. This ensures we don't go beyond the unvisited region.

step 4: Example walk-through

Consider this 3x3 matrix:


[ [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9] ]

Spiral order traversal:

  1. Top row: 1, 2, 3
  2. Right column: 6, 9
  3. Bottom row (reversed): 8, 7
  4. Left column (upward): 4
  5. Remaining element: 5

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

Edge Cases

  • Empty matrix: No elements to print. Return an empty list.
  • Single element: Just return that one value.
  • Single row: Only traverse left to right.
  • Single column: Only traverse top to bottom.
  • More rows than columns: Spiral will loop deeper vertically.
  • More columns than rows: Spiral will loop wider horizontally.

Finally

This spiral traversal technique ensures we visit each element exactly once. It's intuitive when we think in terms of peeling layers, and it works efficiently in O(m × n) time for an m x n matrix. For beginners, always visualize the movement and update of boundaries, and use dry runs with small matrices to build confidence.

Algorithm Steps❯

  1. Given a 2D matrix of size m x n.
  2. Initialize four variables: top = 0, bottom = m - 1, left = 0, right = n - 1.
  3. Traverse the matrix in a spiral form while top <= bottom and left <= right:
  4. → Traverse from left to right across the top row and increment top.
  5. → Traverse from top to bottom along the right column and decrement right.
  6. → If top <= bottom, traverse from right to left across the bottom row and decrement bottom.
  7. → If left <= right, traverse from bottom to top along the left column and increment left.
  8. Repeat until all elements are printed.

Code

C
C++
Python
Java
JS
Go
Rust
Kotlin
TS
#include <stdio.h>

void spiralOrder(int rows, int cols, int matrix[rows][cols]) {
    int top = 0, bottom = rows - 1;
    int left = 0, right = cols - 1;

    while (top <= bottom && left <= right) {
        for (int i = left; i <= right; i++) printf("%d ", matrix[top][i]);
        top++;

        for (int i = top; i <= bottom; i++) printf("%d ", matrix[i][right]);
        right--;

        if (top <= bottom) {
            for (int i = right; i >= left; i--) printf("%d ", matrix[bottom][i]);
            bottom--;
        }

        if (left <= right) {
            for (int i = bottom; i >= top; i--) printf("%d ", matrix[i][left]);
            left++;
        }
    }
}

int main() {
    int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    printf("Spiral Order: ");
    spiralOrder(3, 3, matrix);
    return 0;
}

Comments

💬 Please keep your comment relevant and respectful. Avoid spamming, offensive language, or posting promotional/backlink content.
All comments are subject to moderation before being published.

Loading comments...