Matrix questions are rarely about algorithms. They are about index discipline under pressure: can you rotate a grid without a scratch copy, walk a spiral without re-visiting a row, or mark rows and columns for deletion without a second array to mark them in?

Interviewers like them precisely because they are hard to bluff. There is no clever insight to recall — either your loop bounds are right or your output is scrambled. This page gives you the three reusable tricks that cover almost the whole family.

What you’ll learn

• Transpose + reverse — rotation without allocating a second matrix.
• The four-boundary template that makes spiral traversal off-by-one-proof.
• Using the matrix’s own first row and column as $O(1)$ marker storage.
• Why “read and write in the same pass” is the recurring bug, and the two ways round it.
• Three real LeetCode problems solved in the browser: 48, 54, 73.

The cue

Trick 1 — rotate by transpose, then reverse

Rotating 90° clockwise in place looks like it needs four-way cyclic swaps. It does not. It decomposes into two trivially correct passes:

def rotate(matrix):
    n = len(matrix)
 
    for i in range(n):                  # 1. transpose: swap across the diagonal
        for j in range(i + 1, n):       #    j starts at i+1, NOT 0
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
 
    for row in matrix:                  # 2. reverse each row
        row.reverse()
 
    return matrix
 
 
print(rotate([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
# [[7, 4, 1], [8, 5, 2], [9, 6, 3]]

def rotate(matrix):
    n = len(matrix)
 
    for i in range(n):                  # 1. transpose: swap across the diagonal
        for j in range(i + 1, n):       #    j starts at i+1, NOT 0
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
 
    for row in matrix:                  # 2. reverse each row
        row.reverse()
 
    return matrix
 
 
print(rotate([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
# [[7, 4, 1], [8, 5, 2], [9, 6, 3]]

The other three rotations are the same two moves in different combinations:

Trick 2 — four boundaries for spiral traversal

Track toptop, bottombottom, leftleft, rightright. Walk one edge, then shrink that boundary inward. The whole difficulty is in two guards.

def spiral_order(matrix):
    if not matrix or not matrix[0]:
        return []
 
    top, bottom = 0, len(matrix) - 1
    left, right = 0, len(matrix[0]) - 1
    out = []
 
    while top <= bottom and left <= right:
        for c in range(left, right + 1):            # left -> right along the top
            out.append(matrix[top][c])
        top += 1
 
        for r in range(top, bottom + 1):            # top -> bottom down the right
            out.append(matrix[r][right])
        right -= 1
 
        if top <= bottom:                           # GUARD: row not already taken
            for c in range(right, left - 1, -1):    # right -> left along the bottom
                out.append(matrix[bottom][c])
            bottom -= 1
 
        if left <= right:                           # GUARD: column not already taken
            for r in range(bottom, top - 1, -1):    # bottom -> top up the left
                out.append(matrix[r][left])
            left += 1
 
    return out
 
 
print(spiral_order([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
# [1, 2, 3, 6, 9, 8, 7, 4, 5]

def spiral_order(matrix):
    if not matrix or not matrix[0]:
        return []
 
    top, bottom = 0, len(matrix) - 1
    left, right = 0, len(matrix[0]) - 1
    out = []
 
    while top <= bottom and left <= right:
        for c in range(left, right + 1):            # left -> right along the top
            out.append(matrix[top][c])
        top += 1
 
        for r in range(top, bottom + 1):            # top -> bottom down the right
            out.append(matrix[r][right])
        right -= 1
 
        if top <= bottom:                           # GUARD: row not already taken
            for c in range(right, left - 1, -1):    # right -> left along the bottom
                out.append(matrix[bottom][c])
            bottom -= 1
 
        if left <= right:                           # GUARD: column not already taken
            for r in range(bottom, top - 1, -1):    # bottom -> top up the left
                out.append(matrix[r][left])
            left += 1
 
    return out
 
 
print(spiral_order([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
# [1, 2, 3, 6, 9, 8, 7, 4, 5]

Trick 3 — the matrix as its own marker store

“Set entire row and column to zero wherever you find a zero” has an obvious $O(m + n)$ solution: collect the row and column indices in two sets, then apply. The $O(1)$-space version stores those same flags in row 0 and column 0 of the matrix itself.

The catch: row 0 and column 0 are also real data, and they intersect at matrix[0][0]matrix[0][0], which cannot flag both. So handle them separately with two booleans, do the interior, then finish the borders last.

The variant map

Practice — real LeetCode problems

LC 48 — Rotate Image · Medium

Problem. Given an n x nn x n matrix, rotate it 90° clockwise in place. You must not allocate another matrix.

Constraints. n == len(matrix) == len(matrix[i])n == len(matrix) == len(matrix[i]), 1 <= n <= 201 <= n <= 20, -1000 <= matrix[i][j] <= 1000-1000 <= matrix[i][j] <= 1000.

Examples. [[1,2,3],[4,5,6],[7,8,9]][[1,2,3],[4,5,6],[7,8,9]] gives [[7,4,1],[8,5,2],[9,6,3]][[7,4,1],[8,5,2],[9,6,3]]

LC 54 — Spiral Matrix · Medium

Problem. Given an m x nm x n matrix, return all its elements in spiral order.

Constraints. 1 <= m, n <= 101 <= m, n <= 10, -100 <= matrix[i][j] <= 100-100 <= matrix[i][j] <= 100.

Examples. [[1,2,3],[4,5,6],[7,8,9]][[1,2,3],[4,5,6],[7,8,9]] gives [1,2,3,6,9,8,7,4,5][1,2,3,6,9,8,7,4,5] · [[1,2,3,4],[5,6,7,8],[9,10,11,12]][[1,2,3,4],[5,6,7,8],[9,10,11,12]] gives [1,2,3,4,8,12,11,10,9,5,6,7][1,2,3,4,8,12,11,10,9,5,6,7]

LC 73 — Set Matrix Zeroes · Medium

Problem. Given an m x nm x n matrix, if an element is 00, set its entire row and column to 00. Do it in place.

Constraints. 1 <= m, n <= 2001 <= m, n <= 200, -2^31 <= matrix[i][j] <= 2^31 - 1-2^31 <= matrix[i][j] <= 2^31 - 1. Note that any sentinel value you might pick is a legal matrix entry.

Examples. [[1,1,1],[1,0,1],[1,1,1]][[1,1,1],[1,0,1],[1,1,1]] gives [[1,0,1],[0,0,0],[1,0,1]][[1,0,1],[0,0,0],[1,0,1]] · [[0,1,2,0],[3,4,5,2],[1,3,1,5]][[0,1,2,0],[3,4,5,2],[1,3,1,5]] gives [[0,0,0,0],[0,4,5,0],[0,3,1,0]][[0,0,0,0],[0,4,5,0],[0,3,1,0]]

LeetCode problem set

Interview follow-ups

Edge-case checklist

• 1×1 matrix — every pattern must survive it.
• Single row [[1,2,3]][[1,2,3]] and single column [[1],[2],[3]][[1],[2],[3]] — the spiral guards exist for these; test both, always.
• Empty matrix [][] or [[]][[]] — guard before reading matrix[0]matrix[0].
• Non-square — fine for spiral and transpose, impossible for in-place rotation.
• A zero in row 0 or column 0 (LC 73) — the case the two booleans exist for.
• All zeros / no zeros (LC 73) — the trivial ends of the range.
• Even vs odd nn (LC 48) — an odd nn has a fixed centre cell; make sure your loop bounds neither skip nor double-swap it.
• Duplicate values — never identify a cell by its value; use indices.

Recap

• Rotation in place = transpose, then reverse each row. Inner loop from i + 1i + 1, or you swap everything twice and achieve nothing.
• Spiral traversal = four boundaries, shrink after each walk, and two guards so a lone remaining row or column is not walked twice.
• $O(1)$ space for row/column flags = store them in row 0 and column 0, keep two booleans for the borders, and write the borders last.
• When updates depend on neighbours’ original values, either use two passes or encode both states in one cell.
• No sentinel value is safe when the constraints allow the full integer range.
• Rearranging a grid is this page; searching a grid is BFS/DFS on grids.

Next: Monotonic Stack — the pattern behind next-greater-element and largest-rectangle problems.