Print a Matrix in Spiral Order Optimal Algorithm with Example

Contents

ProblemExamplesVisualizationSolutionAlgorithmCode

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

Visualization Player

Solution❯

To print a matrix in spiral order, we imagine peeling it off layer by layer like an onion—starting from the outermost boundary and working our way in.

We use four pointers to keep track of the current boundaries of the 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

At each step, we follow this order:

  1. Print all elements in the top row from left to right.
  2. Print all elements in the rightmost column from top to bottom.
  3. If rows remain, print the bottom row from right to left.
  4. If columns remain, print the leftmost column from bottom to top.

After each step, we move the boundaries inward (increment top, decrement bottom, etc.). We continue this process while top ≤ bottom and left ≤ right.

Different Cases Explained:

  • Square matrices (e.g., 3x3 or 4x4): These have balanced rows and columns, so the spiral flows symmetrically inward.
  • Rectangular matrices with more rows than columns (e.g., 4x2): Spiral will loop more vertically than horizontally.
  • Rectangular matrices with more columns than rows (e.g., 2x5): Spiral loops outward in a wider pattern.
  • Single row: Just print all elements left to right.
  • Single column: Just print all elements top to bottom.
  • Single element: That element is the entire output.
  • Empty matrix: There are no elements, so output is an empty list.

This method works efficiently in O(m × n) time, where m is the number of rows and n is the number of columns—because we visit each element exactly once.

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

Python
Java
JavaScript
C
C++
C#
Kotlin
Swift
Go
Php
def spiral_order(matrix):
    result = []
    if not matrix:
        return result

    top, bottom = 0, len(matrix) - 1
    left, right = 0, len(matrix[0]) - 1

    while top <= bottom and left <= right:
        # Traverse from left to right
        for i in range(left, right + 1):
            result.append(matrix[top][i])
        top += 1

        # Traverse from top to bottom
        for i in range(top, bottom + 1):
            result.append(matrix[i][right])
        right -= 1

        if top <= bottom:
            # Traverse from right to left
            for i in range(right, left - 1, -1):
                result.append(matrix[bottom][i])
            bottom -= 1

        if left <= right:
            # Traverse from bottom to top
            for i in range(bottom, top - 1, -1):
                result.append(matrix[i][left])
            left += 1

    return result

# Sample Input
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print("Spiral Order:", spiral_order(matrix))