Spiral Matrix II

Spiral Matrix II - Problem

Given a positive integer n, generate an n x n matrix filled with elements from 1 to n² in spiral order.

The spiral order means starting from the top-left corner, moving right across the first row, then down the last column, then left across the bottom row, then up the first column, and repeating this pattern inward until all cells are filled.

Input & Output

Example 1 — Basic 3x3 Matrix

$ Input: n = 3

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

💡 Note: Start from top-left, move right (1,2,3), then down (4,5), then left (6,7), then up (8), then to center (9)

Example 2 — Single Element

$ Input: n = 1

› Output: [[1]]

💡 Note: Only one cell, so matrix contains just [1]

Example 3 — Even Size Matrix

$ Input: n = 4

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

💡 Note: 4x4 matrix filled in spiral order: outer ring (1-12), then inner ring (13-16)

Constraints

1 ≤ n ≤ 20

Visualization

Tap to expand

Asked in

M Microsoft 35 A Amazon 28 F Facebook 22 G Google 18

The key insight is to simulate the spiral movement by tracking four boundaries (top, right, bottom, left) and shrinking them as each side is completed. The optimal approach uses direction simulation with boundary tracking. Time: O(n²), Space: O(n²)

Common Approaches

✓ Direction Simulation

⏱️ Time: O(n²) Space: O(n²)

Start from top-left and move in current direction until hitting a boundary, then turn right and continue. Track four boundaries (top, right, bottom, left) and shrink them as each side is completed.

Layer-by-Layer Construction

⏱️ Time: O(n²) Space: O(n²)

For each position in the matrix, determine which concentric layer it belongs to and calculate its value based on the spiral pattern. Each layer forms a rectangular ring around the previous one.

Direction Simulation — Algorithm Steps

Initialize direction vectors and boundaries
Move in current direction while possible
When boundary hit, turn right and update boundary
Continue until all cells filled

Visualization

Tap to expand

Step-by-Step Walkthrough

Move Right

Fill top row from left to right

Move Down

Fill right column from top to bottom

Move Left & Up

Complete the spiral by filling bottom row and left column

Code -

solution.c — C

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

int** solution(int n, int* returnSize, int** returnColumnSizes) {
    *returnSize = n;
    *returnColumnSizes = (int*)malloc(n * sizeof(int));
    int** matrix = (int**)malloc(n * sizeof(int*));
    
    for (int i = 0; i < n; i++) {
        matrix[i] = (int*)malloc(n * sizeof(int));
        (*returnColumnSizes)[i] = n;
        memset(matrix[i], 0, n * sizeof(int));
    }
    
    int top = 0, bottom = n - 1;
    int left = 0, right = n - 1;
    int num = 1;
    
    while (top <= bottom && left <= right) {
        // Fill top row
        for (int col = left; col <= right; col++) {
            matrix[top][col] = num++;
        }
        top++;
        
        // Fill right column
        for (int row = top; row <= bottom; row++) {
            matrix[row][right] = num++;
        }
        right--;
        
        // Fill bottom row (if exists)
        if (top <= bottom) {
            for (int col = right; col >= left; col--) {
                matrix[bottom][col] = num++;
            }
            bottom--;
        }
        
        // Fill left column (if exists)
        if (left <= right) {
            for (int row = bottom; row >= top; row--) {
                matrix[row][left] = num++;
            }
            left++;
        }
    }
    
    return matrix;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(n, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Visit each cell exactly once in the n×n matrix

⚠ Quadratic Growth

Space Complexity

O(n²)

Need to store the n×n result matrix

⚠ Quadratic Space

125.0K Views

Medium Frequency

~15 min Avg. Time

3.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

Direction Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler