Spiral Matrix - Practice Coding Problems

Spiral Matrix - Problem

Imagine you're a treasure hunter exploring a rectangular grid filled with precious gems. Your goal is to collect all the gems by walking in a spiral pattern - starting from the top-left corner, moving right along the top edge, then down the right edge, left along the bottom, up the left edge, and continuing this spiral pattern inward until you've collected every single gem!

Given an m x n matrix, return all elements traversed in clockwise spiral order. You'll start at matrix[0][0] and spiral inward, collecting elements as you go.

Example: For matrix [[1,2,3],[4,5,6],[7,8,9]], the spiral path would be: 1 → 2 → 3 → 6 → 9 → 8 → 7 → 4 → 5, forming a clockwise spiral from outside to inside.

Input & Output

example_1.py — Standard 3x3 Matrix

$ Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]

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

💡 Note: Start at top-left (1), go right (2,3), down (6,9), left (8,7), up (4), then center (5). This creates a clockwise spiral from outer edge to inner center.

example_2.py — Rectangular Matrix

$ Input: matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]

› Output: [1,2,3,4,8,12,11,10,9,5,6,7]

💡 Note: For non-square matrices, continue the spiral pattern. Go right across top row (1,2,3,4), down right edge (8,12), left across bottom (11,10,9), up left edge (5), then complete inner elements (6,7).

example_3.py — Single Row

$ Input: matrix = [[1,2,3,4]]

› Output: [1,2,3,4]

💡 Note: Edge case: single row matrix. Simply traverse left to right since there's no spiraling possible - just one horizontal line of elements.

Visualization

Tap to expand

Understanding the Visualization

Set Initial Boundaries

Define top=0, bottom=m-1, left=0, right=n-1 as our outer layer

Traverse Right Edge

Move right across the top row, collecting elements from left to right

Shrink Top Boundary

Increment top boundary since we've completed the top row

Traverse Down Edge

Move down the right column from top to bottom

Continue Spiral Pattern

Repeat for left traversal, up traversal, shrinking boundaries each time

Complete All Layers

Continue until all boundaries have been processed

Key Takeaway

🎯 Key Insight: By maintaining four boundaries and systematically shrinking them after each edge traversal, we can simulate the spiral pattern efficiently without extra space for tracking visited cells.

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Visit each cell exactly once in the m×n matrix

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for boundary variables (excluding result array)

✓ Linear Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 10
-100 ≤ matrix[i][j] ≤ 100

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a boundary-based approach with O(1) extra space. Maintain four boundaries (top, bottom, left, right) and shrink them after traversing each edge. This eliminates the need for a visited matrix while naturally following the spiral pattern.

Common Approaches

Approach	Time	Space	Notes
✓ Boundary Simulation (Optimal)	O(m*n)	O(1)	Maintain four boundaries and shrink them as you complete each edge
Brute Force (Visited Matrix)	O(m*n)	O(m*n)	Use a visited matrix to track cells and change direction when hitting boundaries or visited cells

Boundary Simulation (Optimal) — Algorithm Steps

Initialize boundaries: top=0, bottom=m-1, left=0, right=n-1
Traverse right from left to right boundary, then increment top
Traverse down from top to bottom boundary, then decrement right
Traverse left from right to left boundary, then decrement bottom
Traverse up from bottom to top boundary, then increment left
Repeat until boundaries cross

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize boundaries

Set top=0, bottom=2, left=0, right=2

Traverse right edge

Move right along top row, then shrink top boundary

Traverse down edge

Move down along right column, then shrink right boundary

Traverse left edge

Move left along bottom row, then shrink bottom boundary

Traverse up edge

Move up along left column, then shrink left boundary

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize) {
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int m = matrixSize, n = matrixColSize[0];
    int* result = (int*)malloc(m * n * sizeof(int));
    *returnSize = m * n;
    int idx = 0;
    
    int top = 0, bottom = m - 1;
    int left = 0, right = n - 1;
    
    while (top <= bottom && left <= right) {
        // Traverse right
        for (int col = left; col <= right; col++) {
            result[idx++] = matrix[top][col];
        }
        top++;
        
        // Traverse down
        for (int row = top; row <= bottom; row++) {
            result[idx++] = matrix[row][right];
        }
        right--;
        
        // Traverse left (if we still have rows)
        if (top <= bottom) {
            for (int col = right; col >= left; col--) {
                result[idx++] = matrix[bottom][col];
            }
            bottom--;
        }
        
        // Traverse up (if we still have columns)
        if (left <= right) {
            for (int row = bottom; row >= top; row--) {
                result[idx++] = matrix[row][left];
            }
            left++;
        }
    }
    
    return result;
}

int main() {
    // Parse input and call spiralOrder
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Visit each cell exactly once in the m×n matrix

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for boundary variables (excluding result array)

✓ Linear Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 10
-100 ≤ matrix[i][j] ≤ 100

52.3K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Boundary Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler