Introduction

Rotating an N x N matrix by 90 degrees is a standard array-manipulation problem. The two most useful solutions are a simple copy-based approach that is easy to reason about and an in-place approach that uses transpose-plus-reverse to achieve O(1) extra space.

Understand the Coordinate Mapping

For a clockwise rotation, an element at row r and column c moves to:

(r, c) -> (c, n - 1 - r)

That mapping is the real problem. Every correct implementation, whether it uses extra space or not, follows this movement rule.

Take this matrix:

1 2 3
4 5 6
7 8 9

After a clockwise rotation, the result should be:

7 4 1
8 5 2
9 6 3

Keeping that target in mind makes it easier to verify the algorithm.

Copy-Based Solution

The clearest approach is to build a new matrix and write each value into its rotated position.

1def rotate_clockwise_copy(matrix):
2    n = len(matrix)
3    result = [[0] * n for _ in range(n)]
4
5    for r in range(n):
6        for c in range(n):
7            result[c][n - 1 - r] = matrix[r][c]
8
9    return result
10
11
12matrix = [
13    [1, 2, 3],
14    [4, 5, 6],
15    [7, 8, 9],
16]
17
18print(rotate_clockwise_copy(matrix))

This solution is excellent when clarity matters more than memory. It is also the easiest version to adapt to non-square matrices, because it avoids in-place overwriting issues.

In-Place Solution: Transpose Then Reverse

For an N x N matrix, the classic in-place solution has two phases:

1. transpose across the main diagonal,
2. reverse each row.

1def rotate_clockwise_in_place(matrix):
2    n = len(matrix)
3
4    for r in range(n):
5        for c in range(r + 1, n):
6            matrix[r][c], matrix[c][r] = matrix[c][r], matrix[r][c]
7
8    for row in matrix:
9        row.reverse()
10
11
12matrix = [
13    [1, 2, 3],
14    [4, 5, 6],
15    [7, 8, 9],
16]
17
18rotate_clockwise_in_place(matrix)
19print(matrix)

Why this works:

• transposing turns rows into columns,
• reversing each row then reorders those columns into clockwise orientation.

This is the version most interviewers expect when they specifically ask for an in-place solution.

Counterclockwise Rotation

If the rotation should go 90 degrees counterclockwise, you can still transpose first, but the second step changes. Instead of reversing each row, reverse the order of the rows in the matrix.

1def rotate_counterclockwise_in_place(matrix):
2    n = len(matrix)
3
4    for r in range(n):
5        for c in range(r + 1, n):
6            matrix[r][c], matrix[c][r] = matrix[c][r], matrix[r][c]
7
8    matrix.reverse()
9
10
11matrix = [
12    [1, 2, 3],
13    [4, 5, 6],
14    [7, 8, 9],
15]
16
17rotate_counterclockwise_in_place(matrix)
18print(matrix)

The direction matters. Many bugs in this problem are simply clockwise and counterclockwise logic being mixed up.

Complexity and Constraints

Both common solutions touch each element a constant number of times, so time complexity is O(N^2). The difference is in extra memory:

• copy-based rotation uses O(N^2) extra space,
• in-place transpose-and-reverse uses O(1) extra space.

The in-place method assumes the matrix is square. If the matrix is rectangular, the shape changes after a 90-degree rotation, so you typically need a new output matrix.

Common Pitfalls

• Using the wrong coordinate mapping and producing a counterclockwise result by mistake.
• Swapping every transposed pair twice instead of starting the inner loop at r + 1.
• Applying the in-place method to a non-square matrix.
• Writing rotated values back into the original matrix during the copy-based approach and corrupting unread data.
• Forgetting to clarify clockwise versus counterclockwise rotation before coding.

Summary

• A clockwise 90-degree rotation maps (r, c) to (c, n - 1 - r).
• The simplest solution builds a new matrix using that mapping.
• The standard in-place solution is transpose first, then reverse each row.
• Counterclockwise rotation uses a different second step after transpose.
• The optimized in-place version works for square matrices and uses O(1) extra space.