Spiral Matrix

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

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

✓ Boundary Shrinking

⏱️ Time: O(m×n) Space: O(1)

Maintain four boundaries (top, bottom, left, right) and process elements in spiral order by traversing each boundary, then shrinking it inward.

Direction Tracking with Visited Array

⏱️ Time: O(m×n) Space: O(m×n)

Move in current direction until hitting a boundary or visited cell, then turn right and continue. Use a visited array to mark processed cells.

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() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Parse 2D array from input like [[1,2,3],[4,5,6],[7,8,9]]
    int** matrix = NULL;
    int matrixSize = 0;
    int* matrixColSize = NULL;
    
    char* ptr = input;
    while (*ptr && *ptr != '[') ptr++; // Find first '['
    if (*ptr) ptr++; // Skip first '['
    
    // Count rows first
    char* temp = ptr;
    while (*temp) {
        if (*temp == '[') matrixSize++;
        temp++;
    }
    
    if (matrixSize == 0) {
        printf("[]\n");
        return 0;
    }
    
    matrix = (int**)malloc(matrixSize * sizeof(int*));
    matrixColSize = (int*)malloc(matrixSize * sizeof(int));
    
    int row = 0;
    while (*ptr && row < matrixSize) {
        // Find start of row '['
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr) break;
        ptr++; // Skip '['
        
        // Count columns in this row
        char* rowStart = ptr;
        int cols = 0;
        while (*ptr && *ptr != ']') {
            if (*ptr >= '0' && *ptr <= '9') {
                cols++;
                while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
            }
            if (*ptr == ',') ptr++;
        }
        
        matrixColSize[row] = cols;
        matrix[row] = (int*)malloc(cols * sizeof(int));
        
        // Parse numbers in this row
        ptr = rowStart;
        int col = 0;
        while (*ptr && *ptr != ']' && col < cols) {
            if (*ptr >= '0' && *ptr <= '9' || *ptr == '-') {
                matrix[row][col] = strtol(ptr, &ptr, 10);
                col++;
            } else {
                ptr++;
            }
        }
        
        // Skip to end of row ']'
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr) ptr++; // Skip ']'
        
        row++;
    }
    
    int returnSize;
    int* result = solution(matrix, matrixSize, matrixColSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    // Cleanup
    for (int i = 0; i < matrixSize; i++) {
        free(matrix[i]);
    }
    free(matrix);
    free(matrixColSize);
    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

⚡ Linearithmic 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