Spiral Matrix II - Practice Coding Problems

Spiral Matrix II - Problem

You're tasked with creating a spiral matrix - one of the most elegant patterns in computer science! Given a positive integer n, your goal is to generate an n × n matrix filled with consecutive numbers from 1 to n², arranged in a clockwise spiral pattern.

Think of it like drawing a spiral: start 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 you've filled every cell.

Example: For n=3, you should create:

This creates a beautiful spiral pattern that's commonly seen in interview questions at top tech companies!

Input & Output

example_1.py — Small Matrix (n=3)

$ Input: n = 3

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

💡 Note: Starting from top-left, we spiral clockwise: right(1→2→3), down(4→5), left(6←7), up(8), center(9)

example_2.py — Single Cell (n=1)

$ Input: n = 1

› Output: [[1]]

💡 Note: Base case: 1×1 matrix contains only the number 1

example_3.py — Even Size Matrix (n=4)

$ Input: n = 4

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

💡 Note: 4×4 matrix filled in spiral pattern: outer layer (1-12), then inner layer (13-16)

Constraints

1 ≤ n ≤ 20
Matrix is always square (n × n)
Numbers range from 1 to n²

Visualization

Tap to expand

Understanding the Visualization

Set Initial Boundaries

Define four boundaries: top=0, right=n-1, bottom=n-1, left=0

Fill Outer Layer

Complete the outermost layer: top row → right column → bottom row → left column

Shrink Boundaries

Move boundaries inward: top++, right--, bottom--, left++

Repeat for Inner Layers

Continue until all layers are filled and boundaries meet

Handle Center

For odd n, the final layer is a single center cell

Key Takeaway

🎯 Key Insight: By thinking in terms of complete layers rather than individual cells, we eliminate the complexity of direction management and boundary checking, resulting in cleaner, more efficient code.

Asked in

⊞ Microsoft 45 a Amazon 38 G Google 32 Apple 25

The optimal solution uses a layer-by-layer approach where we maintain four boundaries (top, right, bottom, left) and fill each complete layer before moving inward. This eliminates the need for direction checking and visited cell tracking, resulting in clean O(n²) time complexity with optimal space usage.

Common Approaches

Approach	Time	Space	Notes
✓ Layer-by-Layer Approach (Optimal)	O(n²)	O(n²)	Fill the matrix layer by layer, shrinking boundaries after each complete layer

Layer-by-Layer Approach (Optimal) — Algorithm Steps

Initialize four boundaries: top=0, right=n-1, bottom=n-1, left=0
Fill top row from left to right, then increment top boundary
Fill right column from top to bottom, then decrement right boundary
Fill bottom row from right to left, then decrement bottom boundary
Fill left column from bottom to top, then increment left boundary
Repeat until all boundaries meet

Visualization

Tap to expand

Step-by-Step Walkthrough

Outer Layer - Top

Fill top row: 1→2→3

Outer Layer - Right

Fill right column: 4→5

Outer Layer - Bottom

Fill bottom row: 6←7

Outer Layer - Left

Fill left column: 8

Inner Layer

Fill center: 9

Code -

solution.c — C

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

int** generateMatrix(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;
    }
    
    int top = 0, right = n - 1, bottom = n - 1, left = 0;
    int num = 1;
    
    while (top <= bottom && left <= right) {
        // Fill top row (left to right)
        for (int col = left; col <= right; col++) {
            matrix[top][col] = num++;
        }
        top++;
        
        // Fill right column (top to bottom)
        for (int row = top; row <= bottom; row++) {
            matrix[row][right] = num++;
        }
        right--;
        
        // Fill bottom row (right to left)
        if (top <= bottom) {
            for (int col = right; col >= left; col--) {
                matrix[bottom][col] = num++;
            }
            bottom--;
        }
        
        // Fill left column (bottom to top)
        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 = generateMatrix(n, &returnSize, &returnColumnSizes);
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We visit each of the n² cells exactly once

⚠ Quadratic Growth

Space Complexity

O(n²)

Only the space needed for the result matrix, no additional data structures

⚠ Quadratic Space

128.3K Views

High Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Layer-by-Layer Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler