Spiral Matrix - Practice Coding Problems

Spiral Matrix - Problem

Given an m x n matrix, return all elements of the matrix in spiral order.

The spiral order means starting from the top-left corner, move right across the top row, then down the right column, then left across the bottom row, then up the left column, and continue this pattern inward until all elements are visited.

Input & Output

Example 1 — 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 across top row (1,2,3), then down right column (6,9), then left across bottom row (8,7), then up left column (4), finally center (5)

Example 2 — 3x4 Rectangle

$ 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: Top row (1,2,3,4), right column (8,12), bottom row right-to-left (11,10,9), left column bottom-to-top (5), remaining center (6,7)

Example 3 — Single Row

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

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

💡 Note: Only one row, so spiral is just left-to-right traversal

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input Matrix

3x3 matrix with numbers 1-9

Spiral Pattern

Traverse: right → down → left → up → center

Output Array

Elements in spiral order

Key Takeaway

🎯 Key Insight: Use four boundaries that shrink inward after processing each side of the spiral

Asked in

M Microsoft 42 a Amazon 38 G Google 35 Apple 28

The key insight is to maintain four boundaries (top, bottom, left, right) and process elements layer by layer. Best approach is Boundary Shrinking with Time: O(m×n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Boundary Shrinking	O(m×n)	O(1)	Use four boundaries that shrink inward after completing each side
Direction Tracking with Visited Array	O(m×n)	O(m×n)	Track current direction and use visited array to know when to turn

Boundary Shrinking — Algorithm Steps

Initialize four boundaries
Process top row, shrink top boundary
Process right column, shrink right boundary
Process bottom row and left column with boundary checks

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Outer Layer

Traverse top, right, bottom, left boundaries

Shrink Boundaries

Move boundaries inward

Repeat

Continue with inner layers

Code -

solution.c — C

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

int* solution(int** matrix, int matrixSize, int* matrixColSize, int* returnSize) {
    *returnSize = 0;
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        return NULL;
    }
    
    int* result = (int*)malloc(matrixSize * matrixColSize[0] * sizeof(int));
    int top = 0, bottom = matrixSize - 1;
    int left = 0, right = matrixColSize[0] - 1;
    
    while (top <= bottom && left <= right) {
        // Process top row
        for (int col = left; col <= right; col++) {
            result[(*returnSize)++] = matrix[top][col];
        }
        top++;
        
        // Process right column
        for (int row = top; row <= bottom; row++) {
            result[(*returnSize)++] = matrix[row][right];
        }
        right--;
        
        // Process bottom row (if exists)
        if (top <= bottom) {
            for (int col = right; col >= left; col--) {
                result[(*returnSize)++] = matrix[bottom][col];
            }
            bottom--;
        }
        
        // Process left column (if exists)
        if (left <= right) {
            for (int row = bottom; row >= top; row--) {
                result[(*returnSize)++] = matrix[row][left];
            }
            left++;
        }
    }
    
    return result;
}

int main() {
    // Simple parsing for demonstration
    int matrix[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
    int* matrixPtrs[3] = {matrix[0], matrix[1], matrix[2]};
    int matrixColSize[3] = {3, 3, 3};
    int returnSize;
    
    int* result = solution(matrixPtrs, 3, matrixColSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Visit each cell in the matrix exactly once

✓ Linear Growth

Space Complexity

O(1)

Only use constant extra space for boundary variables

✓ Linear Space

277.9K Views

High Frequency

~15 min Avg. Time

8.4K 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

Constraints

Visualization

Related Problems

Common Approaches

Boundary Shrinking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler