Matrix Spiral Traversal - Problem

Given an m x n matrix, return all elements of the matrix in spiral order (clockwise from outside to inside).

The spiral traversal should start from the top-left corner and move in the following pattern:

Move right across the top row
Move down the right column
Move left across the bottom row
Move up the left column
Repeat for inner layers until all elements are visited

Return the elements as a list/array in the order they were visited.

Input & Output

Example 1 — Basic 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 top-left, go right (1→2→3), down (6→9), left (8→7), up (4), then center (5)

Example 2 — Single Row Matrix

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

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

💡 Note: Single row: traverse left to right, no spiral needed

Example 3 — Single Column Matrix

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

› Output: [1,2,3]

💡 Note: Single column: traverse top to bottom, no horizontal movement

Constraints

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

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 42 M Microsoft 28 Apple 15

The key insight is to process the matrix layer by layer, shrinking boundaries after traversing each side of the current rectangle. The optimal approach uses boundary management instead of a visited matrix, achieving O(1) space complexity. Time: O(m×n), Space: O(1).

Common Approaches

✓ Layer-by-Layer Boundary Shrinking

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

Process matrix in concentric rectangular layers. For each layer, traverse top→right→bottom→left, then shrink boundaries inward. No visited tracking needed.

Simulation with Visited Tracking

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

Move in spiral pattern (right, down, left, up) and track visited cells in a separate boolean matrix. Change direction when hitting boundary or visited cell.

Layer-by-Layer Boundary Shrinking — Algorithm Steps

Initialize boundaries: top, bottom, left, right
Process current layer: top row, right column, bottom row, left column
Shrink boundaries inward after each side
Continue until boundaries cross each other

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Boundaries

Initialize top, bottom, left, right boundaries

Process Layer

Traverse current layer: top→right→bottom→left

Shrink Inward

Move boundaries inward after each side

Complete

Continue until boundaries meet

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 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 top row
        for (int col = left; col <= right; col++) {
            result[idx++] = matrix[top][col];
        }
        top++;
        
        // Traverse right column
        for (int row = top; row <= bottom; row++) {
            result[idx++] = matrix[row][right];
        }
        right--;
        
        // Traverse bottom row (if exists)
        if (top <= bottom) {
            for (int col = right; col >= left; col--) {
                result[idx++] = matrix[bottom][col];
            }
            bottom--;
        }
        
        // Traverse left column (if exists)
        if (left <= right) {
            for (int row = bottom; row >= top; row--) {
                result[idx++] = matrix[row][left];
            }
            left++;
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Visit each matrix cell exactly once

✓ Linear Growth

Space Complexity

O(1)

Only use boundary variables and result array

⚡ Linearithmic Space

53.8K Views

High Frequency

~15 min Avg. Time

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

Matrix Spiral Traversal - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Layer-by-Layer Boundary Shrinking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler