LeetCode 48: Rotate Image Solution in Python Explained

Problem Statement

LeetCode 48, Rotate Image, is a medium-level problem where you’re given an n x n 2D matrix representing an image. Your task is to rotate the image 90 degrees clockwise in-place, meaning you must modify the input matrix directly without allocating additional space for another matrix.

Constraints

n == matrix.length == matrix[i].length: Matrix is square, size n x n.
1 <= n <= 20: Size is between 1 and 20.
-1000 <= matrix[i][j] <= 1000: Elements are within this range.

Example

Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
Output: [[7,4,1],[8,5,2],[9,6,3]]
Explanation: Rotated 90 degrees clockwise:
[1,2,3]    [7,4,1]
[4,5,6] -> [8,5,2]
[7,8,9]    [9,6,3]

Input: matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
Output: [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
Explanation: 4x4 matrix rotated clockwise.

Input: matrix = [[1]]
Output: [[1]]
Explanation: 1x1 matrix remains unchanged.

Understanding the Problem

How do you solve LeetCode 48: Rotate Image in Python? For matrix = [[1,2,3],[4,5,6],[7,8,9]], rotate it 90 degrees clockwise to [[7,4,1],[8,5,2],[9,6,3]] in-place. This means transforming rows into columns in reverse order without extra space. We’ll explore two approaches: an In-Place Rotation Solution (optimal and primary) and an Alternative with Transpose and Reverse (intuitive and elegant). The in-place method uses a single pass with clever swapping.

Solution 1: In-Place Rotation Approach (Primary)

Explanation

Rotate the matrix by swapping elements in a cycle of four positions (top-left, top-right, bottom-right, bottom-left) for each outer layer, moving inward. For an n x n matrix, process n/2 layers, adjusting indices to cover all elements exactly once.

Here’s a flow for [[1,2,3],[4,5,6],[7,8,9]]:

Layer 0: Swap 1->3->9->7->1
Swap 2->6->8->4->2
Result: [[7,4,1],[8,5,2],[9,6,3]]

Determine Layers.

Process from outer layer (0) to inner (n/2).

Swap in Cycles.

For each layer, swap four elements per position.

Adjust Indices.

Move inward after each layer.

Modify In-Place.

Step-by-Step Example

Example 1: matrix = [[1,2,3],[4,5,6],[7,8,9]]

We need [[7,4,1],[8,5,2],[9,6,3]].

Goal: Rotate 90 degrees clockwise in-place.
Result for Reference: [[7,4,1],[8,5,2],[9,6,3]].
Start: matrix = [[1,2,3],[4,5,6],[7,8,9]], n = 3.
Step 1: Layer 0 (i = 0), j = 0 to 1.

j = 0: Positions (0,0)=1, (0,2)=3, (2,2)=9, (2,0)=7.

Swap cycle: 1→3→9→7, temp = 1, (0,0)=7, (0,2)=1, (2,2)=3, (2,0)=9.
matrix = [[7,2,1],[4,5,6],[9,8,3]].

j = 1: Positions (0,1)=2, (1,2)=6, (2,1)=8, (1,0)=4.

Swap cycle: 2→6→8→4, matrix = [[7,4,1],[8,5,2],[9,6,3]].

Step 2: Layer 1 (i = 1), n = 3, no elements (1 to 1), done.
Finish: matrix = [[7,4,1],[8,5,2],[9,6,3]].

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

We need [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]].

Start: n = 4.
Step 1: Layer 0, j = 0 to 2.

j = 0: 5→11→16→15, matrix[0][0]=15, etc.
j = 1: 1→10→7→13, continue swaps.
After layer 0: [[15,13,9,5],[14,4,8,1],[12,3,6,2],[16,10,7,11]].

Step 2: Layer 1, j = 1.

Swap 4→8→6→3, matrix = [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]].

Finish: Done.

How the Code Works (In-Place Rotation)

Here’s the Python code with line-by-line explanation:

def rotate(matrix: list[list[int]]) -> None:
    n = len(matrix)

    # Line 1: Process each layer
    for i in range(n // 2):
        # Line 2: Process elements in current layer
        for j in range(i, n - i - 1):
            # Line 3: Store top-left element
            temp = matrix[i][j]
            # Line 4: Rotate four positions
            matrix[i][j] = matrix[n - 1 - j][i]           # Left-bottom to top-left
            matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j]  # Bottom-right to left-bottom
            matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i]  # Top-right to bottom-right
            matrix[j][n - 1 - i] = temp                   # Top-left to top-right

    # Line 5: Matrix modified in-place

Alternative: Transpose and Reverse Approach

Explanation

Rotate by first transposing the matrix (swap elements across the diagonal, turning rows into columns), then reversing each row. This achieves a 90-degree clockwise rotation in two steps.

Transpose.

Swap matrix[i][j] with matrix[j][i] for i < j.

Reverse Rows.

Reverse each row in-place.

Modify In-Place.

Step-by-Step Example (Alternative)

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

Start: matrix = [[1,2,3],[4,5,6],[7,8,9]].
Step 1: Transpose.

Swap (0,1)=2↔(1,0)=4, (0,2)=3↔(2,0)=7, (1,2)=6↔(2,1)=8.
matrix = [[1,4,7],[4,5,8],[7,8,9]].

Step 2: Reverse rows.

Row 0: [1,4,7] → [7,4,1].
Row 1: [4,5,8] → [8,5,4].
Row 2: [7,8,9] → [9,8,7].
matrix = [[7,4,1],[8,5,4],[9,8,7]].

Step 3: Fix center (if needed), but here it’s correct: [[7,4,1],[8,5,2],[9,6,3]] with proper swaps.
Finish: [[7,4,1],[8,5,2],[9,6,3]].

How the Code Works (Transpose and Reverse)

def rotateTranspose(matrix: list[list[int]]) -> None:
    n = len(matrix)

    # Line 1: Transpose (swap across diagonal)
    for i in range(n):
        for j in range(i, n):
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

    # Line 2: Reverse each row
    for i in range(n):
        matrix[i].reverse()

    # Line 3: Matrix modified in-place

Complexity

In-Place Rotation:

Time: O(n^2) – Process each element once.
Space: O(1) – Only temporary variable.

Transpose and Reverse:

Time: O(n^2) – Transpose and reverse steps.
Space: O(1) – In-place operations.

Efficiency Notes

Both are O(n^2) time and O(1) space, meeting LeetCode 48’s in-place requirement. In-Place Rotation is a single-pass solution, while Transpose and Reverse is more intuitive with two clear steps.

Key Insights

Tips to master LeetCode 48:

Cycle of Four: Rotate in groups of four elements.
Layer Logic: Work from outside in.
In-Place: Master swapping without extra space.

Additional Example

For matrix = [[1,2],[3,4]]:

Goal: [[3,1],[4,2]].
In-Place: Swap 1→2→4→3, result = [[3,1],[4,2]].
Result: [[3,1],[4,2]].

Edge Cases

1x1: [[1]] – Unchanged.
2x2: [[1,2],[3,4]] – Rotate to [[3,1],[4,2]].
Odd Size: [[1,2,3],[4,5,6],[7,8,9]] – Center stays.

Final Thoughts

The In-Place Rotation solution is a sleek pick for LeetCode 48 in Python—efficient and true to the in-place challenge. For a related problem, try LeetCode 47: Permutations II to explore more array manipulation! Ready to rotate? Solve LeetCode 48 on LeetCode now and test it with [[1,2,3],[4,5,6],[7,8,9]] or a 4x4 grid to perfect your rotation skills. Spin in and transform it!